Changeset 45609 in webkit

Timestamp:

Jul 7, 2009, 2:52:07 PM (16 years ago)

Author:

[email protected]

Message:

JavaScriptCore:

2009-07-07 Gavin Barraclough <​[email protected]>

Reviewed by Sam Weinig.

Stop loading constants into the register file.

Instead, use high register values (highest bit bar the sign bit set) to indicate
constants in the instruction stream, and when we encounter such a value load it
directly from the CodeBlock.

Since constants are no longer copied into the register file, this patch renders
the 'unexpected constant' mechanism redundant, and removes it.

2% improvement, thanks to Sam Weinig.

• bytecode/CodeBlock.cpp: (JSC::CodeBlock::dump): (JSC::CodeBlock::CodeBlock): (JSC::CodeBlock::mark): (JSC::CodeBlock::shrinkToFit):
• bytecode/CodeBlock.h: (JSC::CodeBlock::isTemporaryRegisterIndex): (JSC::CodeBlock::constantRegister): (JSC::CodeBlock::isConstantRegisterIndex): (JSC::CodeBlock::getConstant): (JSC::ExecState::r):
• bytecode/Opcode.h:
• bytecompiler/BytecodeGenerator.cpp: (JSC::BytecodeGenerator::preserveLastVar): (JSC::BytecodeGenerator::BytecodeGenerator): (JSC::BytecodeGenerator::addConstantValue): (JSC::BytecodeGenerator::emitEqualityOp): (JSC::BytecodeGenerator::emitLoad): (JSC::BytecodeGenerator::emitResolveBase): (JSC::BytecodeGenerator::emitResolveWithBase): (JSC::BytecodeGenerator::emitNewError):
• bytecompiler/BytecodeGenerator.h: (JSC::BytecodeGenerator::emitNode):
• interpreter/CallFrame.h: (JSC::ExecState::noCaller): (JSC::ExecState::hasHostCallFrameFlag): (JSC::ExecState::addHostCallFrameFlag): (JSC::ExecState::removeHostCallFrameFlag):
• interpreter/Interpreter.cpp: (JSC::Interpreter::resolve): (JSC::Interpreter::resolveSkip): (JSC::Interpreter::resolveGlobal): (JSC::Interpreter::resolveBase): (JSC::Interpreter::resolveBaseAndProperty): (JSC::Interpreter::resolveBaseAndFunc): (JSC::Interpreter::dumpRegisters): (JSC::Interpreter::throwException): (JSC::Interpreter::createExceptionScope): (JSC::Interpreter::privateExecute): (JSC::Interpreter::retrieveArguments):
• jit/JIT.cpp: (JSC::JIT::privateCompileMainPass):
• jit/JITInlineMethods.h: (JSC::JIT::emitLoadDouble): (JSC::JIT::emitLoadInt32ToDouble):
• jit/JITOpcodes.cpp: (JSC::JIT::emit_op_new_error): (JSC::JIT::emit_op_enter): (JSC::JIT::emit_op_enter_with_activation):
• parser/Nodes.cpp: (JSC::DeleteResolveNode::emitBytecode): (JSC::DeleteValueNode::emitBytecode): (JSC::PrefixResolveNode::emitBytecode):
• runtime/JSActivation.cpp: (JSC::JSActivation::JSActivation):
• wtf/Platform.h:

LayoutTests:

2009-07-07 Gavin Barraclough <​[email protected]>

Reviewed by Geoff Garen.

fast/js/global-recursion-on-full-stack.html is a little finicky.

The test recurses down the JS stack to find the bottom (catching this with an exception),
then tries to call a host function (document.write), switch writes new '<script>' code,
and expects this code to be run, then expects this code to try to call 'f();' again,
which it expects to fail, and it expects to catch that exception. However it is possible
that one of the earlier stages (the call to document.write, entering the interpreter to
run the new global code) will fail, depending on exactly how much stack space was free at
the point the last call to f() failed.

Tweak the test to make it work.

• fast/js/global-recursion-on-full-stack.html:

Location:

trunk

Files:

• JavaScriptCore/ChangeLog (modified) (1 diff)
• JavaScriptCore/bytecode/CodeBlock.cpp (modified) (8 diffs)
• JavaScriptCore/bytecode/CodeBlock.h (modified) (7 diffs)
• JavaScriptCore/bytecode/Opcode.h (modified) (1 diff)
• JavaScriptCore/bytecompiler/BytecodeGenerator.cpp (modified) (14 diffs)
• JavaScriptCore/bytecompiler/BytecodeGenerator.h (modified) (6 diffs)
• JavaScriptCore/interpreter/CallFrame.h (modified) (2 diffs)
• JavaScriptCore/interpreter/Interpreter.cpp (modified) (144 diffs)
• JavaScriptCore/jit/JIT.cpp (modified) (1 diff)
• JavaScriptCore/jit/JITOpcodes.cpp (modified) (4 diffs)
• JavaScriptCore/parser/Nodes.cpp (modified) (3 diffs)
• JavaScriptCore/runtime/JSActivation.cpp (modified) (1 diff)
• JavaScriptCore/wtf/Platform.h (modified) (2 diffs)
• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/fast/js/global-recursion-on-full-stack.html (modified) (1 diff)

trunk/JavaScriptCore/ChangeLog

@@ +1 @@
+2009-07-07  Gavin Barraclough  <[email protected]>
+
+        Reviewed by Sam Weinig.
+
+        Stop loading constants into the register file.
+
+        Instead, use high register values (highest bit bar the sign bit set) to indicate
+        constants in the instruction stream, and when we encounter such a value load it
+        directly from the CodeBlock.
+
+        Since constants are no longer copied into the register file, this patch renders
+        the 'unexpected constant' mechanism redundant, and removes it.
+
+        2% improvement, thanks to Sam Weinig.
+
+        * bytecode/CodeBlock.cpp:
+        (JSC::CodeBlock::dump):
+        (JSC::CodeBlock::CodeBlock):
+        (JSC::CodeBlock::mark):
+        (JSC::CodeBlock::shrinkToFit):
+        * bytecode/CodeBlock.h:
+        (JSC::CodeBlock::isTemporaryRegisterIndex):
+        (JSC::CodeBlock::constantRegister):
+        (JSC::CodeBlock::isConstantRegisterIndex):
+        (JSC::CodeBlock::getConstant):
+        (JSC::ExecState::r):
+        * bytecode/Opcode.h:
+        * bytecompiler/BytecodeGenerator.cpp:
+        (JSC::BytecodeGenerator::preserveLastVar):
+        (JSC::BytecodeGenerator::BytecodeGenerator):
+        (JSC::BytecodeGenerator::addConstantValue):
+        (JSC::BytecodeGenerator::emitEqualityOp):
+        (JSC::BytecodeGenerator::emitLoad):
+        (JSC::BytecodeGenerator::emitResolveBase):
+        (JSC::BytecodeGenerator::emitResolveWithBase):
+        (JSC::BytecodeGenerator::emitNewError):
+        * bytecompiler/BytecodeGenerator.h:
+        (JSC::BytecodeGenerator::emitNode):
+        * interpreter/CallFrame.h:
+        (JSC::ExecState::noCaller):
+        (JSC::ExecState::hasHostCallFrameFlag):
+        (JSC::ExecState::addHostCallFrameFlag):
+        (JSC::ExecState::removeHostCallFrameFlag):
+        * interpreter/Interpreter.cpp:
+        (JSC::Interpreter::resolve):
+        (JSC::Interpreter::resolveSkip):
+        (JSC::Interpreter::resolveGlobal):
+        (JSC::Interpreter::resolveBase):
+        (JSC::Interpreter::resolveBaseAndProperty):
+        (JSC::Interpreter::resolveBaseAndFunc):
+        (JSC::Interpreter::dumpRegisters):
+        (JSC::Interpreter::throwException):
+        (JSC::Interpreter::createExceptionScope):
+        (JSC::Interpreter::privateExecute):
+        (JSC::Interpreter::retrieveArguments):
+        * jit/JIT.cpp:
+        (JSC::JIT::privateCompileMainPass):
+        * jit/JITInlineMethods.h:
+        (JSC::JIT::emitLoadDouble):
+        (JSC::JIT::emitLoadInt32ToDouble):
+        * jit/JITOpcodes.cpp:
+        (JSC::JIT::emit_op_new_error):
+        (JSC::JIT::emit_op_enter):
+        (JSC::JIT::emit_op_enter_with_activation):
+        * parser/Nodes.cpp:
+        (JSC::DeleteResolveNode::emitBytecode):
+        (JSC::DeleteValueNode::emitBytecode):
+        (JSC::PrefixResolveNode::emitBytecode):
+        * runtime/JSActivation.cpp:
+        (JSC::JSActivation::JSActivation):
+        * wtf/Platform.h:
+
 2009-07-07  Mark Rowe  <[email protected]>
 

trunk/JavaScriptCore/bytecode/CodeBlock.cpp

@@ -364 +364 @@
     }
 
-    if (m_rareData && !m_rareData->m_unexpectedConstants.isEmpty()) {
-        printf("\nUnexpected Constants:\n");
-        size_t i = 0;
-        do {
-            printf("  k%u = %s\n", static_cast<unsigned>(i), valueToSourceString(exec, m_rareData->m_unexpectedConstants[i]).ascii());
-            ++i;
-        } while (i < m_rareData->m_unexpectedConstants.size());
-    }
-    
     if (m_rareData && !m_rareData->m_regexps.isEmpty()) {
         printf("\nm_regexps:\n");
@@ -507 +498 @@
             break;
         }
-        case op_unexpected_load: {
-            int r0 = (++it)->u.operand;
-            int k0 = (++it)->u.operand;
-            printf("[%4d] unexpected_load\t %s, %s\n", location, registerName(r0).c_str(), constantName(exec, k0, unexpectedConstant(k0)).c_str());
-            break;
-        }
         case op_new_object: {
             int r0 = (++it)->u.operand;
@@ -1085 +1070 @@
             int errorType = (++it)->u.operand;
             int k0 = (++it)->u.operand;
-            printf("[%4d] new_error\t %s, %d, %s\n", location, registerName(r0).c_str(), errorType, constantName(exec, k0, unexpectedConstant(k0)).c_str());
+            printf("[%4d] new_error\t %s, %d, %s\n", location, registerName(r0).c_str(), errorType, constantName(exec, k0, getConstant(k0)).c_str());
             break;
         }
@@ -1143 +1128 @@
     macro(regexps) \
     macro(functions) \
-    macro(unexpectedConstants) \
     macro(exceptionHandlers) \
     macro(immediateSwitchJumpTables) \
@@ -1268 +1252 @@
 CodeBlock::CodeBlock(ScopeNode* ownerNode)
     : m_numCalleeRegisters(0)
-    , m_numConstants(0)
     , m_numVars(0)
     , m_numParameters(0)
@@ -1291 +1274 @@
 CodeBlock::CodeBlock(ScopeNode* ownerNode, CodeType codeType, PassRefPtr<SourceProvider> sourceProvider, unsigned sourceOffset)
     : m_numCalleeRegisters(0)
-    , m_numConstants(0)
     , m_numVars(0)
     , m_numParameters(0)
@@ -1456 +1438 @@
             m_rareData->m_functions[i]->body()->mark();
 
-        for (size_t i = 0; i < m_rareData->m_unexpectedConstants.size(); ++i) {
-            if (!m_rareData->m_unexpectedConstants[i].marked())
-                m_rareData->m_unexpectedConstants[i].mark();
-        }
         m_rareData->m_evalCodeCache.mark();
     }
@@ -1758 +1736 @@
         m_rareData->m_exceptionHandlers.shrinkToFit();
         m_rareData->m_functions.shrinkToFit();
-        m_rareData->m_unexpectedConstants.shrinkToFit();
         m_rareData->m_regexps.shrinkToFit();
         m_rareData->m_immediateSwitchJumpTables.shrinkToFit();

trunk/JavaScriptCore/bytecode/CodeBlock.h

@@ -47 +47 @@
 #endif
 
+// Register numbers used in bytecode operations have different meaning accoring to their ranges:
+//      0x80000000-0xFFFFFFFF  Negative indicies from the CallFrame pointer are entries in the call frame, see RegisterFile.h.
+//      0x00000000-0x3FFFFFFF  Forwards indices from the CallFrame pointer are local vars and temporaries with the function's callframe.
+//      0x40000000-0x7FFFFFFF  Positive indices from 0x40000000 specify entries in the constant pool on the CodeBlock.
+static const int FirstConstantRegisterIndex = 0x40000000;
+
 namespace JSC {
 
@@ -249 +255 @@
         }
 
-        ALWAYS_INLINE bool isConstantRegisterIndex(int index)
-        {
-            return index >= m_numVars && index < m_numVars + m_numConstants;
-        }
-
-        ALWAYS_INLINE JSValue getConstant(int index)
-        {
-            return m_constantRegisters[index - m_numVars].jsValue();
-        }
-
         ALWAYS_INLINE bool isTemporaryRegisterIndex(int index)
         {
-            return index >= m_numVars + m_numConstants;
+            return index >= m_numVars;
         }
 
@@ -401 +397 @@
         size_t numberOfConstantRegisters() const { return m_constantRegisters.size(); }
         void addConstantRegister(const Register& r) { return m_constantRegisters.append(r); }
-        Register& constantRegister(int index) { return m_constantRegisters[index]; }
+        Register& constantRegister(int index) { return m_constantRegisters[index - FirstConstantRegisterIndex]; }
+        ALWAYS_INLINE bool isConstantRegisterIndex(int index) { return index >= FirstConstantRegisterIndex; }
+        ALWAYS_INLINE JSValue getConstant(int index) const { return m_constantRegisters[index - FirstConstantRegisterIndex].jsValue(); }
 
         unsigned addFunctionExpression(FuncExprNode* n) { unsigned size = m_functionExpressions.size(); m_functionExpressions.append(n); return size; }
@@ -410 +408 @@
 
         bool hasFunctions() const { return m_functionExpressions.size() || (m_rareData && m_rareData->m_functions.size()); }
-
-        unsigned addUnexpectedConstant(JSValue v) { createRareDataIfNecessary(); unsigned size = m_rareData->m_unexpectedConstants.size(); m_rareData->m_unexpectedConstants.append(v); return size; }
-        JSValue unexpectedConstant(int index) const { ASSERT(m_rareData); return m_rareData->m_unexpectedConstants[index]; }
 
         unsigned addRegExp(RegExp* r) { createRareDataIfNecessary(); unsigned size = m_rareData->m_regexps.size(); m_rareData->m_regexps.append(r); return size; }
@@ -442 +437 @@
 
         int m_numCalleeRegisters;
-        // NOTE: numConstants holds the number of constant registers allocated
-        // by the code generator, not the number of constant registers used.
-        // (Duplicate constants are uniqued during code generation, and spare
-        // constant registers may be allocated.)
-        int m_numConstants;
         int m_numVars;
         int m_numParameters;
@@ -520 +510 @@
             // Rare Constants
             Vector<RefPtr<FuncDeclNode> > m_functions;
-            Vector<JSValue> m_unexpectedConstants;
             Vector<RefPtr<RegExp> > m_regexps;
 
@@ -575 +564 @@
     };
 
+    inline Register& ExecState::r(int index)
+    {
+        CodeBlock* codeBlock = this->codeBlock();
+        if (codeBlock->isConstantRegisterIndex(index))
+            return codeBlock->constantRegister(index);
+        return this[index];
+    }
+
 } // namespace JSC
 

trunk/JavaScriptCore/bytecode/Opcode.h

@@ -45 +45 @@
         macro(op_convert_this, 2) \
         \
-        macro(op_unexpected_load, 3) \
         macro(op_new_object, 2) \
         macro(op_new_array, 4) \

trunk/JavaScriptCore/bytecompiler/BytecodeGenerator.cpp

@@ -197 +197 @@
 }
 
-void BytecodeGenerator::allocateConstants(size_t count)
-{
-    m_codeBlock->m_numConstants = count;
-    if (!count)
-        return;
-    
-    m_nextConstantIndex = m_calleeRegisters.size();
-
-    for (size_t i = 0; i < count; ++i)
-        newRegister();
-    m_lastConstant = &m_calleeRegisters.last();
+void BytecodeGenerator::preserveLastVar()
+{
+    if ((m_firstConstantIndex = m_calleeRegisters.size()) != 0)
+        m_lastVar = &m_calleeRegisters.last();
 }
 
@@ -223 +216 @@
     , m_codeType(GlobalCode)
     , m_nextGlobalIndex(-1)
+    , m_nextConstantOffset(0)
     , m_globalConstantIndex(0)
     , m_globalData(&scopeChain.globalObject()->globalExec()->globalData())
@@ -273 +267 @@
                 newVars.append(addGlobalVar(varStack[i].first, varStack[i].second & DeclarationStacks::IsConstant));
 
-        allocateConstants(programNode->neededConstants());
+        preserveLastVar();
 
         for (size_t i = 0; i < newVars.size(); ++i)
@@ -291 +285 @@
         }
 
-        allocateConstants(programNode->neededConstants());
+        preserveLastVar();
     }
 }
@@ -306 +300 @@
     , m_baseScopeDepth(0)
     , m_codeType(FunctionCode)
+    , m_nextConstantOffset(0)
     , m_globalConstantIndex(0)
     , m_globalData(&scopeChain.globalObject()->globalExec()->globalData())
@@ -373 +368 @@
         addParameter(parameters[i]);
 
-    allocateConstants(functionBody->neededConstants());
+    preserveLastVar();
 }
 
@@ -388 +383 @@
     , m_baseScopeDepth(codeBlock->baseScopeDepth())
     , m_codeType(EvalCode)
+    , m_nextConstantOffset(0)
     , m_globalConstantIndex(0)
     , m_globalData(&scopeChain.globalObject()->globalExec()->globalData())
@@ -402 +398 @@
     m_codeBlock->m_numParameters = 1; // Allocate space for "this"
 
-    allocateConstants(evalNode->neededConstants());
+    preserveLastVar();
 }
 
@@ -792 +788 @@
 }
 
-RegisterID* BytecodeGenerator::addConstant(JSValue v)
-{
-    pair<JSValueMap::iterator, bool> result = m_jsValueMap.add(JSValue::encode(v), m_nextConstantIndex);
+RegisterID* BytecodeGenerator::addConstantValue(JSValue v)
+{
+    int index = m_nextConstantOffset;
+
+    pair<JSValueMap::iterator, bool> result = m_jsValueMap.add(JSValue::encode(v), m_nextConstantOffset);
     if (result.second) {
-        RegisterID& constant = m_calleeRegisters[m_nextConstantIndex];
-        
-        ++m_nextConstantIndex;
-
+        m_constantPoolRegisters.append(FirstConstantRegisterIndex + m_nextConstantOffset);
+        ++m_nextConstantOffset;
         m_codeBlock->addConstantRegister(JSValue(v));
-        return &constant;
-    }
-
-    return &registerFor(result.first->second);
-}
-
-unsigned BytecodeGenerator::addUnexpectedConstant(JSValue v)
-{
-    return m_codeBlock->addUnexpectedConstant(v);
-}
-
-RegisterID* BytecodeGenerator::emitLoadGlobalObject(RegisterID* dst, JSObject* globalObject)
-{
-    if (!m_globalConstantIndex)
-        m_globalConstantIndex = m_codeBlock->addUnexpectedConstant(globalObject);
-    emitOpcode(op_unexpected_load);
-    instructions().append(dst->index());
-    instructions().append(m_globalConstantIndex);
-    return dst;
+    } else
+        index = result.first->second;
+
+    return &m_constantPoolRegisters[index];
 }
 
@@ -899 +880 @@
             && src1->isTemporary()
             && m_codeBlock->isConstantRegisterIndex(src2->index())
-            && m_codeBlock->constantRegister(src2->index() - m_codeBlock->m_numVars).jsValue().isString()) {
-            const UString& value = asString(m_codeBlock->constantRegister(src2->index() - m_codeBlock->m_numVars).jsValue())->value();
+            && m_codeBlock->constantRegister(src2->index()).jsValue().isString()) {
+            const UString& value = asString(m_codeBlock->constantRegister(src2->index()).jsValue())->value();
             if (value == "undefined") {
                 rewindUnaryOp();
@@ -980 +961 @@
 RegisterID* BytecodeGenerator::emitLoad(RegisterID* dst, JSValue v)
 {
-    RegisterID* constantID = addConstant(v);
+    RegisterID* constantID = addConstantValue(v);
     if (dst)
         return emitMove(dst, constantID);
     return constantID;
-}
-
-RegisterID* BytecodeGenerator::emitUnexpectedLoad(RegisterID* dst, bool b)
-{
-    emitOpcode(op_unexpected_load);
-    instructions().append(dst->index());
-    instructions().append(addUnexpectedConstant(jsBoolean(b)));
-    return dst;
-}
-
-RegisterID* BytecodeGenerator::emitUnexpectedLoad(RegisterID* dst, double d)
-{
-    emitOpcode(op_unexpected_load);
-    instructions().append(dst->index());
-    instructions().append(addUnexpectedConstant(jsNumber(globalData(), d)));
-    return dst;
 }
 
@@ -1170 +1135 @@
 
     // Global object is the base
-    return emitLoadGlobalObject(dst, globalObject);
+    return emitLoad(dst, JSValue(globalObject));
 }
 
@@ -1197 +1162 @@
 
     // Global object is the base
-    emitLoadGlobalObject(baseDst, globalObject);
+    emitLoad(baseDst, JSValue(globalObject));
 
     if (index != missingSymbolMarker() && !forceGlobalResolve) {
@@ -1832 +1797 @@
     instructions().append(dst->index());
     instructions().append(static_cast<int>(type));
-    instructions().append(addUnexpectedConstant(message));
+    instructions().append(addConstantValue(message)->index());
     return dst;
 }

trunk/JavaScriptCore/bytecompiler/BytecodeGenerator.h

@@ -246 +246 @@
         RegisterID* emitLoad(RegisterID* dst, const Identifier&);
         RegisterID* emitLoad(RegisterID* dst, JSValue);
-        RegisterID* emitUnexpectedLoad(RegisterID* dst, bool);
-        RegisterID* emitUnexpectedLoad(RegisterID* dst, double);
-        RegisterID* emitLoadGlobalObject(RegisterID* dst, JSObject* globalObject);
 
         RegisterID* emitUnaryOp(OpcodeID, RegisterID* dst, RegisterID* src);
@@ -400 +397 @@
         RegisterID* addParameter(const Identifier&);
         
-        void allocateConstants(size_t);
+        void preserveLastVar();
 
         RegisterID& registerFor(int index)
@@ -421 +418 @@
         unsigned addConstant(FuncExprNode*);
         unsigned addConstant(const Identifier&);
-        RegisterID* addConstant(JSValue);
-        unsigned addUnexpectedConstant(JSValue);
+        RegisterID* addConstantValue(JSValue);
         unsigned addRegExp(RegExp*);
 
@@ -451 +447 @@
         RegisterID m_argumentsRegister;
         int m_activationRegisterIndex;
+        WTF::SegmentedVector<RegisterID, 32> m_constantPoolRegisters;
         WTF::SegmentedVector<RegisterID, 32> m_calleeRegisters;
         WTF::SegmentedVector<RegisterID, 32> m_parameters;
@@ -456 +453 @@
         WTF::SegmentedVector<Label, 32> m_labels;
         WTF::SegmentedVector<LabelScope, 8> m_labelScopes;
-        RefPtr<RegisterID> m_lastConstant;
+        RefPtr<RegisterID> m_lastVar;
         int m_finallyDepth;
         int m_dynamicScopeDepth;
@@ -467 +464 @@
         int m_nextGlobalIndex;
         int m_nextParameterIndex;
-        int m_nextConstantIndex;
+        int m_firstConstantIndex;
+        int m_nextConstantOffset;
         unsigned m_globalConstantIndex;
 

trunk/JavaScriptCore/interpreter/CallFrame.h

@@ -125 +125 @@
         }
 
-    private:
-        friend class Arguments;
-        friend class JSActivation;
-        friend class JSGlobalObject;
-        friend class Interpreter;
-        friend struct CallFrameClosure;
+        // Read a register from the codeframe (or constant from the CodeBlock).
+        inline Register& r(int);
 
+        static CallFrame* noCaller() { return reinterpret_cast<CallFrame*>(HostCallFrameFlag); }
         int returnValueRegister() const { return this[RegisterFile::ReturnValueRegister].i(); }
 
+        bool hasHostCallFrameFlag() const { return reinterpret_cast<intptr_t>(this) & HostCallFrameFlag; }
+        CallFrame* addHostCallFrameFlag() const { return reinterpret_cast<CallFrame*>(reinterpret_cast<intptr_t>(this) | HostCallFrameFlag); }
+        CallFrame* removeHostCallFrameFlag() { return reinterpret_cast<CallFrame*>(reinterpret_cast<intptr_t>(this) & ~HostCallFrameFlag); }
+
+    private:
         void setArgumentCount(int count) { this[RegisterFile::ArgumentCount] = count; }
         void setCallee(JSFunction* callee) { this[RegisterFile::Callee] = callee; }
@@ -139 +141 @@
 
         static const intptr_t HostCallFrameFlag = 1;
-
-        static CallFrame* noCaller() { return reinterpret_cast<CallFrame*>(HostCallFrameFlag); }
-        bool hasHostCallFrameFlag() const { return reinterpret_cast<intptr_t>(this) & HostCallFrameFlag; }
-        CallFrame* addHostCallFrameFlag() const { return reinterpret_cast<CallFrame*>(reinterpret_cast<intptr_t>(this) | HostCallFrameFlag); }
-        CallFrame* removeHostCallFrameFlag() { return reinterpret_cast<CallFrame*>(reinterpret_cast<intptr_t>(this) & ~HostCallFrameFlag); }
 
         ExecState();

trunk/JavaScriptCore/interpreter/Interpreter.cpp

@@ -109 +109 @@
             if (exceptionValue)
                 return false;
-            callFrame[dst] = JSValue(result);
+            callFrame->r(dst) = JSValue(result);
             return true;
         }
@@ -142 +142 @@
             if (exceptionValue)
                 return false;
-            callFrame[dst] = JSValue(result);
+            callFrame->r(dst) = JSValue(result);
             return true;
         }
@@ -160 +160 @@
 
     if (structure == globalObject->structure()) {
-        callFrame[dst] = JSValue(globalObject->getDirectOffset(offset));
+        callFrame->r(dst) = JSValue(globalObject->getDirectOffset(offset));
         return true;
     }
@@ -175 +175 @@
             vPC[4] = globalObject->structure();
             vPC[5] = slot.cachedOffset();
-            callFrame[dst] = JSValue(result);
+            callFrame->r(dst) = JSValue(result);
             return true;
         }
@@ -182 +182 @@
         if (exceptionValue)
             return false;
-        callFrame[dst] = JSValue(result);
+        callFrame->r(dst) = JSValue(result);
         return true;
     }
@@ -194 +194 @@
     int dst = (vPC + 1)->u.operand;
     int property = (vPC + 2)->u.operand;
-    callFrame[dst] = JSValue(JSC::resolveBase(callFrame, callFrame->codeBlock()->identifier(property), callFrame->scopeChain()));
+    callFrame->r(dst) = JSValue(JSC::resolveBase(callFrame, callFrame->codeBlock()->identifier(property), callFrame->scopeChain()));
 }
 
@@ -222 +222 @@
             if (exceptionValue)
                 return false;
-            callFrame[propDst] = JSValue(result);
-            callFrame[baseDst] = JSValue(base);
+            callFrame->r(propDst) = JSValue(result);
+            callFrame->r(baseDst) = JSValue(base);
             return true;
         }
@@ -267 +267 @@
                 return false;
 
-            callFrame[baseDst] = JSValue(thisObj);
-            callFrame[funcDst] = JSValue(result);
+            callFrame->r(baseDst) = JSValue(thisObj);
+            callFrame->r(funcDst) = JSValue(result);
             return true;
         }
@@ -433 +433 @@
     printf("----------------------------------------------------\n");
 
-    end = it + codeBlock->m_numConstants;
-    if (it != end) {
-        do {
-            printf("[r%2d]                      | %10p | %10p \n", registerCount, it, (*it).v());
-            ++it;
-            ++registerCount;
-        } while (it != end);
-    }
-    printf("----------------------------------------------------\n");
-
-    end = it + codeBlock->m_numCalleeRegisters - codeBlock->m_numConstants - codeBlock->m_numVars;
+    end = it + codeBlock->m_numCalleeRegisters - codeBlock->m_numVars;
     if (it != end) {
         do {
@@ -564 +554 @@
 #if !ENABLE(JIT)
         if (isCallBytecode(codeBlock->instructions()[bytecodeOffset].u.opcode))
-            profiler->didExecute(callFrame, callFrame[codeBlock->instructions()[bytecodeOffset + 2].u.operand].jsValue());
+            profiler->didExecute(callFrame, callFrame->r(codeBlock->instructions()[bytecodeOffset + 2].u.operand).jsValue());
         else if (codeBlock->instructions()[bytecodeOffset + 8].u.opcode == getOpcode(op_construct))
-            profiler->didExecute(callFrame, callFrame[codeBlock->instructions()[bytecodeOffset + 10].u.operand].jsValue());
+            profiler->didExecute(callFrame, callFrame->r(codeBlock->instructions()[bytecodeOffset + 10].u.operand).jsValue());
 #else
         int functionRegisterIndex;
         if (codeBlock->functionRegisterForBytecodeOffset(bytecodeOffset, functionRegisterIndex))
-            profiler->didExecute(callFrame, callFrame[functionRegisterIndex].jsValue());
+            profiler->didExecute(callFrame, callFrame->r(functionRegisterIndex).jsValue());
 #endif
     }
@@ -622 +612 @@
 
     CallFrame* newCallFrame = CallFrame::create(oldEnd + codeBlock->m_numParameters + RegisterFile::CallFrameHeaderSize);
-    newCallFrame[codeBlock->thisRegister()] = JSValue(thisObj);
+    newCallFrame->r(codeBlock->thisRegister()) = JSValue(thisObj);
     newCallFrame->init(codeBlock, 0, scopeChain, CallFrame::noCaller(), 0, 0, 0);
 
@@ -679 +669 @@
     CallFrame* newCallFrame = CallFrame::create(oldEnd);
     size_t dst = 0;
-    newCallFrame[0] = JSValue(thisObj);
+    newCallFrame->r(0) = JSValue(thisObj);
     ArgList::const_iterator end = args.end();
     for (ArgList::const_iterator it = args.begin(); it != end; ++it)
-        newCallFrame[++dst] = *it;
+        newCallFrame->r(++dst) = *it;
 
     CodeBlock* codeBlock = &functionBodyNode->bytecode(scopeChain);
@@ -740 +730 @@
     size_t dst = 0;
     for (int i = 0; i < argc; ++i)
-        newCallFrame[++dst] = jsUndefined();
+        newCallFrame->r(++dst) = jsUndefined();
     
     CodeBlock* codeBlock = &functionBodyNode->bytecode(scopeChain);
@@ -851 +841 @@
 
     // a 0 codeBlock indicates a built-in caller
-    newCallFrame[codeBlock->thisRegister()] = JSValue(thisObj);
+    newCallFrame->r(codeBlock->thisRegister()) = JSValue(thisObj);
     newCallFrame->init(codeBlock, 0, scopeChain, callFrame->addHostCallFrameFlag(), 0, 0, 0);
 
@@ -915 +905 @@
     CodeBlock* codeBlock = callFrame->codeBlock();
     Identifier& property = codeBlock->identifier((++vPC)->u.operand);
-    JSValue value = callFrame[(++vPC)->u.operand].jsValue();
+    JSValue value = callFrame->r((++vPC)->u.operand).jsValue();
     JSObject* scope = new (callFrame) JSStaticScopeObject(callFrame, property, value, DontDelete);
-    callFrame[dst] = JSValue(scope);
+    callFrame->r(dst) = JSValue(scope);
 
     return callFrame->scopeChain()->push(scope);
@@ -1194 +1184 @@
         */
         int dst = (++vPC)->u.operand;
-        callFrame[dst] = JSValue(constructEmptyObject(callFrame));
+        callFrame->r(dst) = JSValue(constructEmptyObject(callFrame));
 
         ++vPC;
@@ -1211 +1201 @@
         int argCount = (++vPC)->u.operand;
         ArgList args(callFrame->registers() + firstArg, argCount);
-        callFrame[dst] = JSValue(constructArray(callFrame, args));
+        callFrame->r(dst) = JSValue(constructArray(callFrame, args));
 
         ++vPC;
@@ -1225 +1215 @@
         int dst = (++vPC)->u.operand;
         int regExp = (++vPC)->u.operand;
-        callFrame[dst] = JSValue(new (globalData) RegExpObject(callFrame->scopeChain()->globalObject()->regExpStructure(), callFrame->codeBlock()->regexp(regExp)));
+        callFrame->r(dst) = JSValue(new (globalData) RegExpObject(callFrame->scopeChain()->globalObject()->regExpStructure(), callFrame->codeBlock()->regexp(regExp)));
 
         ++vPC;
@@ -1237 +1227 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = callFrame[src];
+        callFrame->r(dst) = callFrame->r(src);
 
         ++vPC;
@@ -1250 +1240 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue src1 = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue src2 = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src1 = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue src2 = callFrame->r((++vPC)->u.operand).jsValue();
         if (JSFastMath::canDoFastBitwiseOperations(src1, src2))
-            callFrame[dst] = JSFastMath::equal(src1, src2);
+            callFrame->r(dst) = JSFastMath::equal(src1, src2);
         else {
             JSValue result = jsBoolean(JSValue::equalSlowCase(callFrame, src1, src2));
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
         }
 
@@ -1270 +1260 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue src = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src = callFrame->r((++vPC)->u.operand).jsValue();
 
         if (src.isUndefinedOrNull()) {
-            callFrame[dst] = jsBoolean(true);
+            callFrame->r(dst) = jsBoolean(true);
             ++vPC;
             NEXT_INSTRUCTION();
         }
         
-        callFrame[dst] = jsBoolean(src.isCell() && src.asCell()->structure()->typeInfo().masqueradesAsUndefined());
+        callFrame->r(dst) = jsBoolean(src.isCell() && src.asCell()->structure()->typeInfo().masqueradesAsUndefined());
         ++vPC;
         NEXT_INSTRUCTION();
@@ -1290 +1280 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue src1 = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue src2 = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src1 = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue src2 = callFrame->r((++vPC)->u.operand).jsValue();
         if (JSFastMath::canDoFastBitwiseOperations(src1, src2))
-            callFrame[dst] = JSFastMath::notEqual(src1, src2);
+            callFrame->r(dst) = JSFastMath::notEqual(src1, src2);
         else {
             JSValue result = jsBoolean(!JSValue::equalSlowCase(callFrame, src1, src2));
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
         }
 
@@ -1310 +1300 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue src = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src = callFrame->r((++vPC)->u.operand).jsValue();
 
         if (src.isUndefinedOrNull()) {
-            callFrame[dst] = jsBoolean(false);
+            callFrame->r(dst) = jsBoolean(false);
             ++vPC;
             NEXT_INSTRUCTION();
         }
         
-        callFrame[dst] = jsBoolean(!src.isCell() || !asCell(src)->structure()->typeInfo().masqueradesAsUndefined());
+        callFrame->r(dst) = jsBoolean(!src.isCell() || !asCell(src)->structure()->typeInfo().masqueradesAsUndefined());
         ++vPC;
         NEXT_INSTRUCTION();
@@ -1330 +1320 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue src1 = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue src2 = callFrame[(++vPC)->u.operand].jsValue();
-        callFrame[dst] = jsBoolean(JSValue::strictEqual(src1, src2));
+        JSValue src1 = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue src2 = callFrame->r((++vPC)->u.operand).jsValue();
+        callFrame->r(dst) = jsBoolean(JSValue::strictEqual(src1, src2));
 
         ++vPC;
@@ -1345 +1335 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue src1 = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue src2 = callFrame[(++vPC)->u.operand].jsValue();
-        callFrame[dst] = jsBoolean(!JSValue::strictEqual(src1, src2));
+        JSValue src1 = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue src2 = callFrame->r((++vPC)->u.operand).jsValue();
+        callFrame->r(dst) = jsBoolean(!JSValue::strictEqual(src1, src2));
 
         ++vPC;
@@ -1360 +1350 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue src1 = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue src2 = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src1 = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue src2 = callFrame->r((++vPC)->u.operand).jsValue();
         JSValue result = jsBoolean(jsLess(callFrame, src1, src2));
         CHECK_FOR_EXCEPTION();
-        callFrame[dst] = result;
+        callFrame->r(dst) = result;
 
         ++vPC;
@@ -1377 +1367 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue src1 = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue src2 = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src1 = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue src2 = callFrame->r((++vPC)->u.operand).jsValue();
         JSValue result = jsBoolean(jsLessEq(callFrame, src1, src2));
         CHECK_FOR_EXCEPTION();
-        callFrame[dst] = result;
+        callFrame->r(dst) = result;
 
         ++vPC;
@@ -1393 +1383 @@
         */
         int srcDst = (++vPC)->u.operand;
-        JSValue v = callFrame[srcDst].jsValue();
+        JSValue v = callFrame->r(srcDst).jsValue();
         if (JSFastMath::canDoFastAdditiveOperations(v))
-            callFrame[srcDst] = JSValue(JSFastMath::incImmediateNumber(v));
+            callFrame->r(srcDst) = JSValue(JSFastMath::incImmediateNumber(v));
         else {
             JSValue result = jsNumber(callFrame, v.toNumber(callFrame) + 1);
             CHECK_FOR_EXCEPTION();
-            callFrame[srcDst] = result;
+            callFrame->r(srcDst) = result;
         }
 
@@ -1412 +1402 @@
         */
         int srcDst = (++vPC)->u.operand;
-        JSValue v = callFrame[srcDst].jsValue();
+        JSValue v = callFrame->r(srcDst).jsValue();
         if (JSFastMath::canDoFastAdditiveOperations(v))
-            callFrame[srcDst] = JSValue(JSFastMath::decImmediateNumber(v));
+            callFrame->r(srcDst) = JSValue(JSFastMath::decImmediateNumber(v));
         else {
             JSValue result = jsNumber(callFrame, v.toNumber(callFrame) - 1);
             CHECK_FOR_EXCEPTION();
-            callFrame[srcDst] = result;
+            callFrame->r(srcDst) = result;
         }
 
@@ -1433 +1423 @@
         int dst = (++vPC)->u.operand;
         int srcDst = (++vPC)->u.operand;
-        JSValue v = callFrame[srcDst].jsValue();
+        JSValue v = callFrame->r(srcDst).jsValue();
         if (JSFastMath::canDoFastAdditiveOperations(v)) {
-            callFrame[dst] = v;
-            callFrame[srcDst] = JSValue(JSFastMath::incImmediateNumber(v));
+            callFrame->r(dst) = v;
+            callFrame->r(srcDst) = JSValue(JSFastMath::incImmediateNumber(v));
         } else {
-            JSValue number = callFrame[srcDst].jsValue().toJSNumber(callFrame);
+            JSValue number = callFrame->r(srcDst).jsValue().toJSNumber(callFrame);
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = number;
-            callFrame[srcDst] = JSValue(jsNumber(callFrame, number.uncheckedGetNumber() + 1));
+            callFrame->r(dst) = number;
+            callFrame->r(srcDst) = JSValue(jsNumber(callFrame, number.uncheckedGetNumber() + 1));
         }
 
@@ -1456 +1446 @@
         int dst = (++vPC)->u.operand;
         int srcDst = (++vPC)->u.operand;
-        JSValue v = callFrame[srcDst].jsValue();
+        JSValue v = callFrame->r(srcDst).jsValue();
         if (JSFastMath::canDoFastAdditiveOperations(v)) {
-            callFrame[dst] = v;
-            callFrame[srcDst] = JSValue(JSFastMath::decImmediateNumber(v));
+            callFrame->r(dst) = v;
+            callFrame->r(srcDst) = JSValue(JSFastMath::decImmediateNumber(v));
         } else {
-            JSValue number = callFrame[srcDst].jsValue().toJSNumber(callFrame);
+            JSValue number = callFrame->r(srcDst).jsValue().toJSNumber(callFrame);
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = number;
-            callFrame[srcDst] = JSValue(jsNumber(callFrame, number.uncheckedGetNumber() - 1));
+            callFrame->r(dst) = number;
+            callFrame->r(srcDst) = JSValue(jsNumber(callFrame, number.uncheckedGetNumber() - 1));
         }
 
@@ -1479 +1469 @@
         int src = (++vPC)->u.operand;
 
-        JSValue srcVal = callFrame[src].jsValue();
+        JSValue srcVal = callFrame->r(src).jsValue();
 
         if (LIKELY(srcVal.isNumber()))
-            callFrame[dst] = callFrame[src];
+            callFrame->r(dst) = callFrame->r(src);
         else {
             JSValue result = srcVal.toJSNumber(callFrame);
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
         }
 
@@ -1499 +1489 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue src = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src = callFrame->r((++vPC)->u.operand).jsValue();
         ++vPC;
         double v;
         if (src.getNumber(v))
-            callFrame[dst] = JSValue(jsNumber(callFrame, -v));
+            callFrame->r(dst) = JSValue(jsNumber(callFrame, -v));
         else {
             JSValue result = jsNumber(callFrame, -src.toNumber(callFrame));
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
         }
 
@@ -1520 +1510 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue src1 = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue src2 = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src1 = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue src2 = callFrame->r((++vPC)->u.operand).jsValue();
         if (JSFastMath::canDoFastAdditiveOperations(src1, src2))
-            callFrame[dst] = JSValue(JSFastMath::addImmediateNumbers(src1, src2));
+            callFrame->r(dst) = JSValue(JSFastMath::addImmediateNumbers(src1, src2));
         else {
             JSValue result = jsAdd(callFrame, src1, src2);
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
         }
         vPC += 2;
@@ -1539 +1529 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue src1 = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue src2 = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src1 = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue src2 = callFrame->r((++vPC)->u.operand).jsValue();
         double left;
         double right;
@@ -1547 +1537 @@
             int32_t right = src2.getInt32Fast();
             if ((left | right) >> 15 == 0)
-                callFrame[dst] = JSValue(jsNumber(callFrame, left * right));
+                callFrame->r(dst) = JSValue(jsNumber(callFrame, left * right));
             else
-                callFrame[dst] = JSValue(jsNumber(callFrame, static_cast<double>(left) * static_cast<double>(right)));
+                callFrame->r(dst) = JSValue(jsNumber(callFrame, static_cast<double>(left) * static_cast<double>(right)));
         } else if (src1.getNumber(left) && src2.getNumber(right))
-            callFrame[dst] = JSValue(jsNumber(callFrame, left * right));
+            callFrame->r(dst) = JSValue(jsNumber(callFrame, left * right));
         else {
             JSValue result = jsNumber(callFrame, src1.toNumber(callFrame) * src2.toNumber(callFrame));
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
         }
 
@@ -1569 +1559 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue dividend = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue divisor = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue dividend = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue divisor = callFrame->r((++vPC)->u.operand).jsValue();
         double left;
         double right;
         if (dividend.getNumber(left) && divisor.getNumber(right))
-            callFrame[dst] = JSValue(jsNumber(callFrame, left / right));
+            callFrame->r(dst) = JSValue(jsNumber(callFrame, left / right));
         else {
             JSValue result = jsNumber(callFrame, dividend.toNumber(callFrame) / divisor.toNumber(callFrame));
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
         }
         ++vPC;
@@ -1594 +1584 @@
         int divisor = (++vPC)->u.operand;
 
-        JSValue dividendValue = callFrame[dividend].jsValue();
-        JSValue divisorValue = callFrame[divisor].jsValue();
+        JSValue dividendValue = callFrame->r(dividend).jsValue();
+        JSValue divisorValue = callFrame->r(divisor).jsValue();
 
         if (JSValue::areBothInt32Fast(dividendValue, divisorValue) && divisorValue != jsNumber(callFrame, 0)) {
@@ -1602 +1592 @@
             JSValue result = JSValue::makeInt32Fast(dividendValue.getInt32Fast() % divisorValue.getInt32Fast());
             ASSERT(result);
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
             ++vPC;
             NEXT_INSTRUCTION();
@@ -1610 +1600 @@
         JSValue result = jsNumber(callFrame, fmod(d, divisorValue.toNumber(callFrame)));
         CHECK_FOR_EXCEPTION();
-        callFrame[dst] = result;
+        callFrame->r(dst) = result;
         ++vPC;
         NEXT_INSTRUCTION();
@@ -1622 +1612 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue src1 = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue src2 = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src1 = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue src2 = callFrame->r((++vPC)->u.operand).jsValue();
         double left;
         double right;
         if (JSFastMath::canDoFastAdditiveOperations(src1, src2))
-            callFrame[dst] = JSValue(JSFastMath::subImmediateNumbers(src1, src2));
+            callFrame->r(dst) = JSValue(JSFastMath::subImmediateNumbers(src1, src2));
         else if (src1.getNumber(left) && src2.getNumber(right))
-            callFrame[dst] = JSValue(jsNumber(callFrame, left - right));
+            callFrame->r(dst) = JSValue(jsNumber(callFrame, left - right));
         else {
             JSValue result = jsNumber(callFrame, src1.toNumber(callFrame) - src2.toNumber(callFrame));
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
         }
         vPC += 2;
@@ -1646 +1636 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue val = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue shift = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue val = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue shift = callFrame->r((++vPC)->u.operand).jsValue();
         int32_t left;
         uint32_t right;
         if (JSValue::areBothInt32Fast(val, shift))
-            callFrame[dst] = JSValue(jsNumber(callFrame, val.getInt32Fast() << (shift.getInt32Fast() & 0x1f)));
+            callFrame->r(dst) = JSValue(jsNumber(callFrame, val.getInt32Fast() << (shift.getInt32Fast() & 0x1f)));
         else if (val.numberToInt32(left) && shift.numberToUInt32(right))
-            callFrame[dst] = JSValue(jsNumber(callFrame, left << (right & 0x1f)));
+            callFrame->r(dst) = JSValue(jsNumber(callFrame, left << (right & 0x1f)));
         else {
             JSValue result = jsNumber(callFrame, (val.toInt32(callFrame)) << (shift.toUInt32(callFrame) & 0x1f));
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
         }
 
@@ -1671 +1661 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue val = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue shift = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue val = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue shift = callFrame->r((++vPC)->u.operand).jsValue();
         int32_t left;
         uint32_t right;
         if (JSFastMath::canDoFastRshift(val, shift))
-            callFrame[dst] = JSValue(JSFastMath::rightShiftImmediateNumbers(val, shift));
+            callFrame->r(dst) = JSValue(JSFastMath::rightShiftImmediateNumbers(val, shift));
         else if (val.numberToInt32(left) && shift.numberToUInt32(right))
-            callFrame[dst] = JSValue(jsNumber(callFrame, left >> (right & 0x1f)));
+            callFrame->r(dst) = JSValue(jsNumber(callFrame, left >> (right & 0x1f)));
         else {
             JSValue result = jsNumber(callFrame, (val.toInt32(callFrame)) >> (shift.toUInt32(callFrame) & 0x1f));
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
         }
 
@@ -1696 +1686 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue val = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue shift = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue val = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue shift = callFrame->r((++vPC)->u.operand).jsValue();
         if (JSFastMath::canDoFastUrshift(val, shift))
-            callFrame[dst] = JSValue(JSFastMath::rightShiftImmediateNumbers(val, shift));
+            callFrame->r(dst) = JSValue(JSFastMath::rightShiftImmediateNumbers(val, shift));
         else {
             JSValue result = jsNumber(callFrame, (val.toUInt32(callFrame)) >> (shift.toUInt32(callFrame) & 0x1f));
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
         }
 
@@ -1717 +1707 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue src1 = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue src2 = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src1 = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue src2 = callFrame->r((++vPC)->u.operand).jsValue();
         int32_t left;
         int32_t right;
         if (JSFastMath::canDoFastBitwiseOperations(src1, src2))
-            callFrame[dst] = JSValue(JSFastMath::andImmediateNumbers(src1, src2));
+            callFrame->r(dst) = JSValue(JSFastMath::andImmediateNumbers(src1, src2));
         else if (src1.numberToInt32(left) && src2.numberToInt32(right))
-            callFrame[dst] = JSValue(jsNumber(callFrame, left & right));
+            callFrame->r(dst) = JSValue(jsNumber(callFrame, left & right));
         else {
             JSValue result = jsNumber(callFrame, src1.toInt32(callFrame) & src2.toInt32(callFrame));
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
         }
 
@@ -1742 +1732 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue src1 = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue src2 = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src1 = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue src2 = callFrame->r((++vPC)->u.operand).jsValue();
         int32_t left;
         int32_t right;
         if (JSFastMath::canDoFastBitwiseOperations(src1, src2))
-            callFrame[dst] = JSValue(JSFastMath::xorImmediateNumbers(src1, src2));
+            callFrame->r(dst) = JSValue(JSFastMath::xorImmediateNumbers(src1, src2));
         else if (src1.numberToInt32(left) && src2.numberToInt32(right))
-            callFrame[dst] = JSValue(jsNumber(callFrame, left ^ right));
+            callFrame->r(dst) = JSValue(jsNumber(callFrame, left ^ right));
         else {
             JSValue result = jsNumber(callFrame, src1.toInt32(callFrame) ^ src2.toInt32(callFrame));
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
         }
 
@@ -1767 +1757 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue src1 = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue src2 = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src1 = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue src2 = callFrame->r((++vPC)->u.operand).jsValue();
         int32_t left;
         int32_t right;
         if (JSFastMath::canDoFastBitwiseOperations(src1, src2))
-            callFrame[dst] = JSValue(JSFastMath::orImmediateNumbers(src1, src2));
+            callFrame->r(dst) = JSValue(JSFastMath::orImmediateNumbers(src1, src2));
         else if (src1.numberToInt32(left) && src2.numberToInt32(right))
-            callFrame[dst] = JSValue(jsNumber(callFrame, left | right));
+            callFrame->r(dst) = JSValue(jsNumber(callFrame, left | right));
         else {
             JSValue result = jsNumber(callFrame, src1.toInt32(callFrame) | src2.toInt32(callFrame));
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
         }
 
@@ -1791 +1781 @@
         */
         int dst = (++vPC)->u.operand;
-        JSValue src = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src = callFrame->r((++vPC)->u.operand).jsValue();
         int32_t value;
         if (src.numberToInt32(value))
-            callFrame[dst] = JSValue(jsNumber(callFrame, ~value));
+            callFrame->r(dst) = JSValue(jsNumber(callFrame, ~value));
         else {
             JSValue result = jsNumber(callFrame, ~src.toInt32(callFrame));
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
         }
         ++vPC;
@@ -1811 +1801 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        JSValue result = jsBoolean(!callFrame[src].jsValue().toBoolean(callFrame));
+        JSValue result = jsBoolean(!callFrame->r(src).jsValue().toBoolean(callFrame));
         CHECK_FOR_EXCEPTION();
-        callFrame[dst] = result;
+        callFrame->r(dst) = result;
 
         ++vPC;
@@ -1836 +1826 @@
         int baseProto = vPC[4].u.operand;
 
-        JSValue baseVal = callFrame[base].jsValue();
+        JSValue baseVal = callFrame->r(base).jsValue();
 
         if (isInvalidParamForInstanceOf(callFrame, callFrame->codeBlock(), vPC, baseVal, exceptionValue))
             goto vm_throw;
 
-        bool result = asObject(baseVal)->hasInstance(callFrame, callFrame[value].jsValue(), callFrame[baseProto].jsValue());
+        bool result = asObject(baseVal)->hasInstance(callFrame, callFrame->r(value).jsValue(), callFrame->r(baseProto).jsValue());
         CHECK_FOR_EXCEPTION();
-        callFrame[dst] = jsBoolean(result);
+        callFrame->r(dst) = jsBoolean(result);
 
         vPC += 5;
@@ -1856 +1846 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = JSValue(jsTypeStringForValue(callFrame, callFrame[src].jsValue()));
+        callFrame->r(dst) = JSValue(jsTypeStringForValue(callFrame, callFrame->r(src).jsValue()));
 
         ++vPC;
@@ -1870 +1860 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        JSValue v = callFrame[src].jsValue();
-        callFrame[dst] = jsBoolean(v.isCell() ? v.asCell()->structure()->typeInfo().masqueradesAsUndefined() : v.isUndefined());
+        JSValue v = callFrame->r(src).jsValue();
+        callFrame->r(dst) = jsBoolean(v.isCell() ? v.asCell()->structure()->typeInfo().masqueradesAsUndefined() : v.isUndefined());
 
         ++vPC;
@@ -1885 +1875 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = jsBoolean(callFrame[src].jsValue().isBoolean());
+        callFrame->r(dst) = jsBoolean(callFrame->r(src).jsValue().isBoolean());
 
         ++vPC;
@@ -1899 +1889 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = jsBoolean(callFrame[src].jsValue().isNumber());
+        callFrame->r(dst) = jsBoolean(callFrame->r(src).jsValue().isNumber());
 
         ++vPC;
@@ -1913 +1903 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = jsBoolean(callFrame[src].jsValue().isString());
+        callFrame->r(dst) = jsBoolean(callFrame->r(src).jsValue().isString());
 
         ++vPC;
@@ -1927 +1917 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = jsBoolean(jsIsObjectType(callFrame[src].jsValue()));
+        callFrame->r(dst) = jsBoolean(jsIsObjectType(callFrame->r(src).jsValue()));
 
         ++vPC;
@@ -1941 +1931 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        callFrame[dst] = jsBoolean(jsIsFunctionType(callFrame[src].jsValue()));
+        callFrame->r(dst) = jsBoolean(jsIsFunctionType(callFrame->r(src).jsValue()));
 
         ++vPC;
@@ -1959 +1949 @@
         int base = (++vPC)->u.operand;
 
-        JSValue baseVal = callFrame[base].jsValue();
+        JSValue baseVal = callFrame->r(base).jsValue();
         if (isInvalidParamForIn(callFrame, callFrame->codeBlock(), vPC, baseVal, exceptionValue))
             goto vm_throw;
@@ -1965 +1955 @@
         JSObject* baseObj = asObject(baseVal);
 
-        JSValue propName = callFrame[property].jsValue();
+        JSValue propName = callFrame->r(property).jsValue();
 
         uint32_t i;
         if (propName.getUInt32(i))
-            callFrame[dst] = jsBoolean(baseObj->hasProperty(callFrame, i));
+            callFrame->r(dst) = jsBoolean(baseObj->hasProperty(callFrame, i));
         else {
             Identifier property(callFrame, propName.toString(callFrame));
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = jsBoolean(baseObj->hasProperty(callFrame, property));
+            callFrame->r(dst) = jsBoolean(baseObj->hasProperty(callFrame, property));
         }
 
@@ -2031 +2021 @@
         int index = (++vPC)->u.operand;
 
-        callFrame[dst] = scope->registerAt(index);
+        callFrame->r(dst) = scope->registerAt(index);
         ++vPC;
         NEXT_INSTRUCTION();
@@ -2045 +2035 @@
         int value = (++vPC)->u.operand;
         
-        scope->registerAt(index) = JSValue(callFrame[value].jsValue());
+        scope->registerAt(index) = JSValue(callFrame->r(value).jsValue());
         ++vPC;
         NEXT_INSTRUCTION();
@@ -2070 +2060 @@
         ASSERT((*iter)->isVariableObject());
         JSVariableObject* scope = static_cast<JSVariableObject*>(*iter);
-        callFrame[dst] = scope->registerAt(index);
+        callFrame->r(dst) = scope->registerAt(index);
         ++vPC;
         NEXT_INSTRUCTION();
@@ -2093 +2083 @@
         ASSERT((*iter)->isVariableObject());
         JSVariableObject* scope = static_cast<JSVariableObject*>(*iter);
-        scope->registerAt(index) = JSValue(callFrame[value].jsValue());
+        scope->registerAt(index) = JSValue(callFrame->r(value).jsValue());
         ++vPC;
         NEXT_INSTRUCTION();
@@ -2161 +2151 @@
         CodeBlock* codeBlock = callFrame->codeBlock();
         Identifier& ident = codeBlock->identifier(property);
-        JSValue baseValue = callFrame[base].jsValue();
+        JSValue baseValue = callFrame->r(base).jsValue();
         PropertySlot slot(baseValue);
         JSValue result = baseValue.get(callFrame, ident, slot);
@@ -2168 +2158 @@
         tryCacheGetByID(callFrame, codeBlock, vPC, baseValue, ident, slot);
 
-        callFrame[dst] = result;
+        callFrame->r(dst) = result;
         vPC += 8;
         NEXT_INSTRUCTION();
@@ -2180 +2170 @@
         */
         int base = vPC[2].u.operand;
-        JSValue baseValue = callFrame[base].jsValue();
+        JSValue baseValue = callFrame->r(base).jsValue();
 
         if (LIKELY(baseValue.isCell())) {
@@ -2193 +2183 @@
 
                 ASSERT(baseObject->get(callFrame, callFrame->codeBlock()->identifier(vPC[3].u.operand)) == baseObject->getDirectOffset(offset));
-                callFrame[dst] = JSValue(baseObject->getDirectOffset(offset));
+                callFrame->r(dst) = JSValue(baseObject->getDirectOffset(offset));
 
                 vPC += 8;
@@ -2211 +2201 @@
         */
         int base = vPC[2].u.operand;
-        JSValue baseValue = callFrame[base].jsValue();
+        JSValue baseValue = callFrame->r(base).jsValue();
 
         if (LIKELY(baseValue.isCell())) {
@@ -2227 +2217 @@
 
                     ASSERT(protoObject->get(callFrame, callFrame->codeBlock()->identifier(vPC[3].u.operand)) == protoObject->getDirectOffset(offset));
-                    callFrame[dst] = JSValue(protoObject->getDirectOffset(offset));
+                    callFrame->r(dst) = JSValue(protoObject->getDirectOffset(offset));
 
                     vPC += 8;
@@ -2260 +2250 @@
         */
         int base = vPC[2].u.operand;
-        JSValue baseValue = callFrame[base].jsValue();
+        JSValue baseValue = callFrame->r(base).jsValue();
 
         if (LIKELY(baseValue.isCell())) {
@@ -2282 +2272 @@
 
                         ASSERT(baseObject->get(callFrame, callFrame->codeBlock()->identifier(vPC[3].u.operand)) == baseObject->getDirectOffset(offset));
-                        callFrame[dst] = JSValue(baseObject->getDirectOffset(offset));
+                        callFrame->r(dst) = JSValue(baseObject->getDirectOffset(offset));
 
                         vPC += 8;
@@ -2308 +2298 @@
 
         Identifier& ident = callFrame->codeBlock()->identifier(property);
-        JSValue baseValue = callFrame[base].jsValue();
+        JSValue baseValue = callFrame->r(base).jsValue();
         PropertySlot slot(baseValue);
         JSValue result = baseValue.get(callFrame, ident, slot);
         CHECK_FOR_EXCEPTION();
 
-        callFrame[dst] = result;
+        callFrame->r(dst) = result;
         vPC += 8;
         NEXT_INSTRUCTION();
@@ -2326 +2316 @@
 
         int base = vPC[2].u.operand;
-        JSValue baseValue = callFrame[base].jsValue();
+        JSValue baseValue = callFrame->r(base).jsValue();
         if (LIKELY(isJSArray(globalData, baseValue))) {
             int dst = vPC[1].u.operand;
-            callFrame[dst] = JSValue(jsNumber(callFrame, asArray(baseValue)->length()));
+            callFrame->r(dst) = JSValue(jsNumber(callFrame, asArray(baseValue)->length()));
             vPC += 8;
             NEXT_INSTRUCTION();
@@ -2346 +2336 @@
 
         int base = vPC[2].u.operand;
-        JSValue baseValue = callFrame[base].jsValue();
+        JSValue baseValue = callFrame->r(base).jsValue();
         if (LIKELY(isJSString(globalData, baseValue))) {
             int dst = vPC[1].u.operand;
-            callFrame[dst] = JSValue(jsNumber(callFrame, asString(baseValue)->value().size()));
+            callFrame->r(dst) = JSValue(jsNumber(callFrame, asString(baseValue)->value().size()));
             vPC += 8;
             NEXT_INSTRUCTION();
@@ -2372 +2362 @@
 
         CodeBlock* codeBlock = callFrame->codeBlock();
-        JSValue baseValue = callFrame[base].jsValue();
+        JSValue baseValue = callFrame->r(base).jsValue();
         Identifier& ident = codeBlock->identifier(property);
         PutPropertySlot slot;
-        baseValue.put(callFrame, ident, callFrame[value].jsValue(), slot);
+        baseValue.put(callFrame, ident, callFrame->r(value).jsValue(), slot);
         CHECK_FOR_EXCEPTION();
 
@@ -2395 +2385 @@
          */
         int base = vPC[1].u.operand;
-        JSValue baseValue = callFrame[base].jsValue();
+        JSValue baseValue = callFrame->r(base).jsValue();
         
         if (LIKELY(baseValue.isCell())) {
@@ -2423 +2413 @@
                 unsigned offset = vPC[7].u.operand;
                 ASSERT(baseObject->offsetForLocation(baseObject->getDirectLocation(callFrame->codeBlock()->identifier(vPC[2].u.operand))) == offset);
-                baseObject->putDirectOffset(offset, callFrame[value].jsValue());
+                baseObject->putDirectOffset(offset, callFrame->r(value).jsValue());
 
                 vPC += 8;
@@ -2445 +2435 @@
         */
         int base = vPC[1].u.operand;
-        JSValue baseValue = callFrame[base].jsValue();
+        JSValue baseValue = callFrame->r(base).jsValue();
 
         if (LIKELY(baseValue.isCell())) {
@@ -2458 +2448 @@
                 
                 ASSERT(baseObject->offsetForLocation(baseObject->getDirectLocation(callFrame->codeBlock()->identifier(vPC[2].u.operand))) == offset);
-                baseObject->putDirectOffset(offset, callFrame[value].jsValue());
+                baseObject->putDirectOffset(offset, callFrame->r(value).jsValue());
 
                 vPC += 8;
@@ -2481 +2471 @@
         int value = vPC[3].u.operand;
 
-        JSValue baseValue = callFrame[base].jsValue();
+        JSValue baseValue = callFrame->r(base).jsValue();
         Identifier& ident = callFrame->codeBlock()->identifier(property);
         PutPropertySlot slot;
-        baseValue.put(callFrame, ident, callFrame[value].jsValue(), slot);
+        baseValue.put(callFrame, ident, callFrame->r(value).jsValue(), slot);
         CHECK_FOR_EXCEPTION();
 
@@ -2502 +2492 @@
         int property = (++vPC)->u.operand;
 
-        JSObject* baseObj = callFrame[base].jsValue().toObject(callFrame);
+        JSObject* baseObj = callFrame->r(base).jsValue().toObject(callFrame);
         Identifier& ident = callFrame->codeBlock()->identifier(property);
         JSValue result = jsBoolean(baseObj->deleteProperty(callFrame, ident));
         CHECK_FOR_EXCEPTION();
-        callFrame[dst] = result;
+        callFrame->r(dst) = result;
         ++vPC;
         NEXT_INSTRUCTION();
@@ -2522 +2512 @@
         int property = (++vPC)->u.operand;
         
-        JSValue baseValue = callFrame[base].jsValue();
-        JSValue subscript = callFrame[property].jsValue();
+        JSValue baseValue = callFrame->r(base).jsValue();
+        JSValue subscript = callFrame->r(property).jsValue();
 
         JSValue result;
@@ -2547 +2537 @@
 
         CHECK_FOR_EXCEPTION();
-        callFrame[dst] = result;
+        callFrame->r(dst) = result;
         ++vPC;
         NEXT_INSTRUCTION();
@@ -2566 +2556 @@
         int value = (++vPC)->u.operand;
 
-        JSValue baseValue = callFrame[base].jsValue();
-        JSValue subscript = callFrame[property].jsValue();
+        JSValue baseValue = callFrame->r(base).jsValue();
+        JSValue subscript = callFrame->r(property).jsValue();
 
         if (LIKELY(subscript.isUInt32Fast())) {
@@ -2574 +2564 @@
                 JSArray* jsArray = asArray(baseValue);
                 if (jsArray->canSetIndex(i))
-                    jsArray->setIndex(i, callFrame[value].jsValue());
+                    jsArray->setIndex(i, callFrame->r(value).jsValue());
                 else
-                    jsArray->JSArray::put(callFrame, i, callFrame[value].jsValue());
+                    jsArray->JSArray::put(callFrame, i, callFrame->r(value).jsValue());
             } else if (isJSByteArray(globalData, baseValue) && asByteArray(baseValue)->canAccessIndex(i)) {
                 JSByteArray* jsByteArray = asByteArray(baseValue);
                 double dValue = 0;
-                JSValue jsValue = callFrame[value].jsValue();
+                JSValue jsValue = callFrame->r(value).jsValue();
                 if (jsValue.isInt32Fast())
                     jsByteArray->setIndex(i, jsValue.getInt32Fast());
@@ -2588 +2578 @@
                     baseValue.put(callFrame, i, jsValue);
             } else
-                baseValue.put(callFrame, i, callFrame[value].jsValue());
+                baseValue.put(callFrame, i, callFrame->r(value).jsValue());
         } else {
             Identifier property(callFrame, subscript.toString(callFrame));
             if (!globalData->exception) { // Don't put to an object if toString threw an exception.
                 PutPropertySlot slot;
-                baseValue.put(callFrame, property, callFrame[value].jsValue(), slot);
+                baseValue.put(callFrame, property, callFrame->r(value).jsValue(), slot);
             }
         }
@@ -2613 +2603 @@
         int property = (++vPC)->u.operand;
 
-        JSObject* baseObj = callFrame[base].jsValue().toObject(callFrame); // may throw
-
-        JSValue subscript = callFrame[property].jsValue();
+        JSObject* baseObj = callFrame->r(base).jsValue().toObject(callFrame); // may throw
+
+        JSValue subscript = callFrame->r(property).jsValue();
         JSValue result;
         uint32_t i;
@@ -2628 +2618 @@
 
         CHECK_FOR_EXCEPTION();
-        callFrame[dst] = result;
+        callFrame->r(dst) = result;
         ++vPC;
         NEXT_INSTRUCTION();
@@ -2648 +2638 @@
         int value = (++vPC)->u.operand;
 
-        callFrame[base].jsValue().put(callFrame, property, callFrame[value].jsValue());
+        callFrame->r(base).jsValue().put(callFrame, property, callFrame->r(value).jsValue());
 
         ++vPC;
@@ -2695 +2685 @@
         int cond = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        if (callFrame[cond].jsValue().toBoolean(callFrame)) {
+        if (callFrame->r(cond).jsValue().toBoolean(callFrame)) {
             vPC += target;
             CHECK_FOR_TIMEOUT();
@@ -2712 +2702 @@
         int cond = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        if (callFrame[cond].jsValue().toBoolean(callFrame)) {
+        if (callFrame->r(cond).jsValue().toBoolean(callFrame)) {
             vPC += target;
             NEXT_INSTRUCTION();
@@ -2728 +2718 @@
         int cond = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        if (!callFrame[cond].jsValue().toBoolean(callFrame)) {
+        if (!callFrame->r(cond).jsValue().toBoolean(callFrame)) {
             vPC += target;
             NEXT_INSTRUCTION();
@@ -2744 +2734 @@
         int src = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        JSValue srcValue = callFrame[src].jsValue();
+        JSValue srcValue = callFrame->r(src).jsValue();
 
         if (srcValue.isUndefinedOrNull() || (srcValue.isCell() && srcValue.asCell()->structure()->typeInfo().masqueradesAsUndefined())) {
@@ -2762 +2752 @@
         int src = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        JSValue srcValue = callFrame[src].jsValue();
+        JSValue srcValue = callFrame->r(src).jsValue();
 
         if (!srcValue.isUndefinedOrNull() || (srcValue.isCell() && !srcValue.asCell()->structure()->typeInfo().masqueradesAsUndefined())) {
@@ -2781 +2771 @@
         JSValue ptr = JSValue((++vPC)->u.jsCell);
         int target = (++vPC)->u.operand;
-        JSValue srcValue = callFrame[src].jsValue();
+        JSValue srcValue = callFrame->r(src).jsValue();
         if (srcValue != ptr) {
             vPC += target;
@@ -2801 +2791 @@
            the JS timeout is reached.
          */
-        JSValue src1 = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue src2 = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src1 = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue src2 = callFrame->r((++vPC)->u.operand).jsValue();
         int target = (++vPC)->u.operand;
         
@@ -2828 +2818 @@
            the JS timeout is reached.
         */
-        JSValue src1 = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue src2 = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src1 = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue src2 = callFrame->r((++vPC)->u.operand).jsValue();
         int target = (++vPC)->u.operand;
         
@@ -2852 +2842 @@
            result of the comparison is false.
         */
-        JSValue src1 = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue src2 = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src1 = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue src2 = callFrame->r((++vPC)->u.operand).jsValue();
         int target = (++vPC)->u.operand;
 
@@ -2875 +2865 @@
            if and only if theresult of the comparison is false.
         */
-        JSValue src1 = callFrame[(++vPC)->u.operand].jsValue();
-        JSValue src2 = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue src1 = callFrame->r((++vPC)->u.operand).jsValue();
+        JSValue src2 = callFrame->r((++vPC)->u.operand).jsValue();
         int target = (++vPC)->u.operand;
 
@@ -2901 +2891 @@
         int tableIndex = (++vPC)->u.operand;
         int defaultOffset = (++vPC)->u.operand;
-        JSValue scrutinee = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue scrutinee = callFrame->r((++vPC)->u.operand).jsValue();
         if (scrutinee.isInt32Fast())
             vPC += callFrame->codeBlock()->immediateSwitchJumpTable(tableIndex).offsetForValue(scrutinee.getInt32Fast(), defaultOffset);
@@ -2925 +2915 @@
         int tableIndex = (++vPC)->u.operand;
         int defaultOffset = (++vPC)->u.operand;
-        JSValue scrutinee = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue scrutinee = callFrame->r((++vPC)->u.operand).jsValue();
         if (!scrutinee.isString())
             vPC += defaultOffset;
@@ -2948 +2938 @@
         int tableIndex = (++vPC)->u.operand;
         int defaultOffset = (++vPC)->u.operand;
-        JSValue scrutinee = callFrame[(++vPC)->u.operand].jsValue();
+        JSValue scrutinee = callFrame->r((++vPC)->u.operand).jsValue();
         if (!scrutinee.isString())
             vPC += defaultOffset;
@@ -2966 +2956 @@
         int func = (++vPC)->u.operand;
 
-        callFrame[dst] = callFrame->codeBlock()->function(func)->makeFunction(callFrame, callFrame->scopeChain());
+        callFrame->r(dst) = callFrame->codeBlock()->function(func)->makeFunction(callFrame, callFrame->scopeChain());
 
         ++vPC;
@@ -2982 +2972 @@
         int func = (++vPC)->u.operand;
 
-        callFrame[dst] = callFrame->codeBlock()->functionExpression(func)->makeFunction(callFrame, callFrame->scopeChain());
+        callFrame->r(dst) = callFrame->codeBlock()->functionExpression(func)->makeFunction(callFrame, callFrame->scopeChain());
 
         ++vPC;
@@ -3004 +2994 @@
         int registerOffset = vPC[4].u.operand;
 
-        JSValue funcVal = callFrame[func].jsValue();
+        JSValue funcVal = callFrame->r(func).jsValue();
 
         Register* newCallFrame = callFrame->registers() + registerOffset;
@@ -3015 +3005 @@
             if (exceptionValue)
                 goto vm_throw;
-            callFrame[dst] = result;
+            callFrame->r(dst) = result;
 
             vPC += 5;
@@ -3041 +3031 @@
         int registerOffset = vPC[4].u.operand;
 
-        JSValue v = callFrame[func].jsValue();
+        JSValue v = callFrame->r(func).jsValue();
 
         CallData callData;
@@ -3090 +3080 @@
             CHECK_FOR_EXCEPTION();
 
-            callFrame[dst] = JSValue(returnValue);
+            callFrame->r(dst) = JSValue(returnValue);
 
             vPC += 5;
@@ -3105 +3095 @@
         int argsOffset = (++vPC)->u.operand;
         
-        JSValue arguments = callFrame[argsOffset].jsValue();
+        JSValue arguments = callFrame->r(argsOffset).jsValue();
         uint32_t argCount = 0;
         if (!arguments) {
-            argCount = (uint32_t)(callFrame[RegisterFile::ArgumentCount].u.i) - 1;
+            argCount = (uint32_t)(callFrame->argumentCount()) - 1;
             int32_t sizeDelta = argsOffset + argCount + RegisterFile::CallFrameHeaderSize;
             Register* newEnd = callFrame->registers() + sizeDelta;
@@ -3115 +3105 @@
                 goto vm_throw;
             }
-            uint32_t expectedParams = asFunction(callFrame[RegisterFile::Callee].jsValue())->body()->parameterCount();
+            uint32_t expectedParams = callFrame->callee()->body()->parameterCount();
             uint32_t inplaceArgs = min(argCount, expectedParams);
             uint32_t i = 0;
@@ -3173 +3163 @@
         }
         CHECK_FOR_EXCEPTION();
-        callFrame[argCountDst] = argCount + 1;
+        callFrame->r(argCountDst) = argCount + 1;
         ++vPC;
         NEXT_INSTRUCTION();
@@ -3194 +3184 @@
         int registerOffset = vPC[4].u.operand;
         
-        JSValue v = callFrame[func].jsValue();
-        int argCount = callFrame[argCountReg].i();
+        JSValue v = callFrame->r(func).jsValue();
+        int argCount = callFrame->r(argCountReg).i();
         registerOffset += argCount;
         CallData callData;
@@ -3244 +3234 @@
             CHECK_FOR_EXCEPTION();
             
-            callFrame[dst] = JSValue(returnValue);
+            callFrame->r(dst) = JSValue(returnValue);
             
             vPC += 5;
@@ -3271 +3261 @@
         ASSERT(callFrame->codeBlock()->needsFullScopeChain());
 
-        asActivation(callFrame[src].jsValue())->copyRegisters(callFrame->optionalCalleeArguments());
+        asActivation(callFrame->r(src).jsValue())->copyRegisters(callFrame->optionalCalleeArguments());
 
         ++vPC;
@@ -3311 +3301 @@
             callFrame->scopeChain()->deref();
 
-        JSValue returnValue = callFrame[result].jsValue();
+        JSValue returnValue = callFrame->r(result).jsValue();
 
         vPC = callFrame->returnPC();
@@ -3320 +3310 @@
             return returnValue;
 
-        callFrame[dst] = JSValue(returnValue);
+        callFrame->r(dst) = JSValue(returnValue);
 
         NEXT_INSTRUCTION();
@@ -3339 +3329 @@
         
         for (size_t count = codeBlock->m_numVars; i < count; ++i)
-            callFrame[i] = jsUndefined();
-
-        for (size_t count = codeBlock->numberOfConstantRegisters(), j = 0; j < count; ++i, ++j)
-            callFrame[i] = codeBlock->constantRegister(j);
+            callFrame->r(i) = jsUndefined();
 
         ++vPC;
@@ -3364 +3351 @@
 
         for (size_t count = codeBlock->m_numVars; i < count; ++i)
-            callFrame[i] = jsUndefined();
-
-        for (size_t count = codeBlock->numberOfConstantRegisters(), j = 0; j < count; ++i, ++j)
-            callFrame[i] = codeBlock->constantRegister(j);
+            callFrame->r(i) = jsUndefined();
 
         int dst = (++vPC)->u.operand;
         JSActivation* activation = new (globalData) JSActivation(callFrame, static_cast<FunctionBodyNode*>(codeBlock->ownerNode()));
-        callFrame[dst] = activation;
+        callFrame->r(dst) = activation;
         callFrame->setScopeChain(callFrame->scopeChain()->copy()->push(activation));
 
@@ -3390 +3374 @@
 
         int thisRegister = (++vPC)->u.operand;
-        JSValue thisVal = callFrame[thisRegister].jsValue();
+        JSValue thisVal = callFrame->r(thisRegister).jsValue();
         if (thisVal.needsThisConversion())
-            callFrame[thisRegister] = JSValue(thisVal.toThisObject(callFrame));
+            callFrame->r(thisRegister) = JSValue(thisVal.toThisObject(callFrame));
 
         ++vPC;
@@ -3407 +3391 @@
            block.
          */
-        callFrame[RegisterFile::ArgumentsRegister] = JSValue();
+        callFrame->r(RegisterFile::ArgumentsRegister) = JSValue();
         ++vPC;
         NEXT_INSTRUCTION();
@@ -3422 +3406 @@
              Arguments* arguments = new (globalData) Arguments(callFrame);
              callFrame->setCalleeArguments(arguments);
-             callFrame[RegisterFile::ArgumentsRegister] = arguments;
+             callFrame->r(RegisterFile::ArgumentsRegister) = arguments;
          }
         ++vPC;
@@ -3449 +3433 @@
         int thisRegister = vPC[6].u.operand;
 
-        JSValue v = callFrame[func].jsValue();
+        JSValue v = callFrame->r(func).jsValue();
 
         ConstructData constructData;
@@ -3460 +3444 @@
 
             Structure* structure;
-            JSValue prototype = callFrame[proto].jsValue();
+            JSValue prototype = callFrame->r(proto).jsValue();
             if (prototype.isObject())
                 structure = asObject(prototype)->inheritorID();
@@ -3467 +3451 @@
             JSObject* newObject = new (globalData) JSObject(structure);
 
-            callFrame[thisRegister] = JSValue(newObject); // "this" value
+            callFrame->r(thisRegister) = JSValue(newObject); // "this" value
 
             CallFrame* previousCallFrame = callFrame;
@@ -3501 +3485 @@
             }
             CHECK_FOR_EXCEPTION();
-            callFrame[dst] = JSValue(returnValue);
+            callFrame->r(dst) = JSValue(returnValue);
 
             vPC += 7;
@@ -3520 +3504 @@
 
         int dst = vPC[1].u.operand;
-        if (LIKELY(callFrame[dst].jsValue().isObject())) {
+        if (LIKELY(callFrame->r(dst).jsValue().isObject())) {
             vPC += 3;
             NEXT_INSTRUCTION();
@@ -3526 +3510 @@
 
         int override = vPC[2].u.operand;
-        callFrame[dst] = callFrame[override];
+        callFrame->r(dst) = callFrame->r(override);
 
         vPC += 3;
@@ -3536 +3520 @@
         int count = (++vPC)->u.operand;
 
-        callFrame[dst] = concatenateStrings(callFrame, &callFrame->registers()[src], count);
+        callFrame->r(dst) = concatenateStrings(callFrame, &callFrame->registers()[src], count);
         ++vPC;
 
@@ -3545 +3529 @@
         int src = (++vPC)->u.operand;
 
-        callFrame[dst] = callFrame[src].jsValue().toPrimitive(callFrame);
+        callFrame->r(dst) = callFrame->r(src).jsValue().toPrimitive(callFrame);
         ++vPC;
 
@@ -3558 +3542 @@
         */
         int scope = (++vPC)->u.operand;
-        JSValue v = callFrame[scope].jsValue();
+        JSValue v = callFrame->r(scope).jsValue();
         JSObject* o = v.toObject(callFrame);
         CHECK_FOR_EXCEPTION();
 
-        callFrame[scope] = JSValue(o);
+        callFrame->r(scope) = JSValue(o);
         callFrame->setScopeChain(callFrame->scopeChain()->push(o));
 
@@ -3589 +3573 @@
         int base = (++vPC)->u.operand;
 
-        callFrame[dst] = JSPropertyNameIterator::create(callFrame, callFrame[base].jsValue());
+        callFrame->r(dst) = JSPropertyNameIterator::create(callFrame, callFrame->r(base).jsValue());
         ++vPC;
         NEXT_INSTRUCTION();
@@ -3606 +3590 @@
         int target = (++vPC)->u.operand;
 
-        JSPropertyNameIterator* it = callFrame[iter].propertyNameIterator();
+        JSPropertyNameIterator* it = callFrame->r(iter).propertyNameIterator();
         if (JSValue temp = it->next(callFrame)) {
             CHECK_FOR_TIMEOUT();
-            callFrame[dst] = JSValue(temp);
+            callFrame->r(dst) = JSValue(temp);
             vPC += target;
             NEXT_INSTRUCTION();
@@ -3665 +3649 @@
         ASSERT(!globalData->exception);
         int ex = (++vPC)->u.operand;
-        callFrame[ex] = exceptionValue;
+        callFrame->r(ex) = exceptionValue;
         exceptionValue = JSValue();
 
@@ -3683 +3667 @@
 
         int ex = (++vPC)->u.operand;
-        exceptionValue = callFrame[ex].jsValue();
+        exceptionValue = callFrame->r(ex).jsValue();
 
         handler = throwException(callFrame, exceptionValue, vPC - callFrame->codeBlock()->instructions().begin(), true);
@@ -3694 +3678 @@
         NEXT_INSTRUCTION();
     }
-    DEFINE_OPCODE(op_unexpected_load) {
-        /* unexpected_load load dst(r) src(k)
-
-           Copies constant src to register dst.
-        */
-        int dst = (++vPC)->u.operand;
-        int src = (++vPC)->u.operand;
-        callFrame[dst] = JSValue(callFrame->codeBlock()->unexpectedConstant(src));
-
-        ++vPC;
-        NEXT_INSTRUCTION();
-    }
     DEFINE_OPCODE(op_new_error) {
         /* new_error dst(r) type(n) message(k)
@@ -3719 +3691 @@
 
         CodeBlock* codeBlock = callFrame->codeBlock();
-        callFrame[dst] = JSValue(Error::create(callFrame, (ErrorType)type, codeBlock->unexpectedConstant(message).toString(callFrame), codeBlock->lineNumberForBytecodeOffset(callFrame, vPC - codeBlock->instructions().begin()), codeBlock->ownerNode()->sourceID(), codeBlock->ownerNode()->sourceURL()));
+        callFrame->r(dst) = JSValue(Error::create(callFrame, (ErrorType)type, callFrame->r(message).jsValue().toString(callFrame), codeBlock->lineNumberForBytecodeOffset(callFrame, vPC - codeBlock->instructions().begin()), codeBlock->ownerNode()->sourceID(), codeBlock->ownerNode()->sourceURL()));
 
         ++vPC;
@@ -3737 +3709 @@
         }
         int result = (++vPC)->u.operand;
-        return callFrame[result].jsValue();
+        return callFrame->r(result).jsValue();
     }
     DEFINE_OPCODE(op_put_getter) {
@@ -3754 +3726 @@
         int function = (++vPC)->u.operand;
 
-        ASSERT(callFrame[base].jsValue().isObject());
-        JSObject* baseObj = asObject(callFrame[base].jsValue());
+        ASSERT(callFrame->r(base).jsValue().isObject());
+        JSObject* baseObj = asObject(callFrame->r(base).jsValue());
         Identifier& ident = callFrame->codeBlock()->identifier(property);
-        ASSERT(callFrame[function].jsValue().isObject());
-        baseObj->defineGetter(callFrame, ident, asObject(callFrame[function].jsValue()));
+        ASSERT(callFrame->r(function).jsValue().isObject());
+        baseObj->defineGetter(callFrame, ident, asObject(callFrame->r(function).jsValue()));
 
         ++vPC;
@@ -3778 +3750 @@
         int function = (++vPC)->u.operand;
 
-        ASSERT(callFrame[base].jsValue().isObject());
-        JSObject* baseObj = asObject(callFrame[base].jsValue());
+        ASSERT(callFrame->r(base).jsValue().isObject());
+        JSObject* baseObj = asObject(callFrame->r(base).jsValue());
         Identifier& ident = callFrame->codeBlock()->identifier(property);
-        ASSERT(callFrame[function].jsValue().isObject());
-        baseObj->defineSetter(callFrame, ident, asObject(callFrame[function].jsValue()));
+        ASSERT(callFrame->r(function).jsValue().isObject());
+        baseObj->defineSetter(callFrame, ident, asObject(callFrame->r(function).jsValue()));
 
         ++vPC;
@@ -3799 +3771 @@
         int retAddrDst = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        callFrame[retAddrDst] = vPC + 1;
+        callFrame->r(retAddrDst) = vPC + 1;
 
         vPC += target;
@@ -3812 +3784 @@
         */
         int retAddrSrc = (++vPC)->u.operand;
-        vPC = callFrame[retAddrSrc].vPC();
+        vPC = callFrame->r(retAddrSrc).vPC();
         NEXT_INSTRUCTION();
     }
@@ -3839 +3811 @@
 
         if (*enabledProfilerReference)
-            (*enabledProfilerReference)->willExecute(callFrame, callFrame[function].jsValue());
+            (*enabledProfilerReference)->willExecute(callFrame, callFrame->r(function).jsValue());
 
         vPC += 2;
@@ -3853 +3825 @@
 
         if (*enabledProfilerReference)
-            (*enabledProfilerReference)->didExecute(callFrame, callFrame[function].jsValue());
+            (*enabledProfilerReference)->didExecute(callFrame, callFrame->r(function).jsValue());
 
         vPC += 2;
@@ -3896 +3868 @@
         SymbolTable& symbolTable = codeBlock->symbolTable();
         int argumentsIndex = symbolTable.get(functionCallFrame->propertyNames().arguments.ustring().rep()).getIndex();
-        if (!functionCallFrame[argumentsIndex].arguments()) {
+        if (!functionCallFrame->r(argumentsIndex).arguments()) {
             Arguments* arguments = new (callFrame) Arguments(functionCallFrame);
             functionCallFrame->setCalleeArguments(arguments);
-            functionCallFrame[RegisterFile::ArgumentsRegister] = arguments;
-        }
-        return functionCallFrame[argumentsIndex].jsValue();
+            functionCallFrame->r(RegisterFile::ArgumentsRegister) = arguments;
+        }
+        return functionCallFrame->r(argumentsIndex).jsValue();
     }
 

trunk/JavaScriptCore/jit/JIT.cpp

@@ -276 +276 @@
         DEFINE_OP(op_to_jsnumber)
         DEFINE_OP(op_to_primitive)
-        DEFINE_OP(op_unexpected_load)
 
         case op_get_array_length:

trunk/JavaScriptCore/jit/JITOpcodes.cpp

@@ -506 +506 @@
 }
 
-void JIT::emit_op_unexpected_load(Instruction* currentInstruction)
-{
-    JSValue v = m_codeBlock->unexpectedConstant(currentInstruction[2].u.operand);
-    move(ImmPtr(JSValue::encode(v)), regT0);
-    emitPutVirtualRegister(currentInstruction[1].u.operand);
-}
-
 void JIT::emit_op_jsr(Instruction* currentInstruction)
 {
@@ -760 +753 @@
     JITStubCall stubCall(this, JITStubs::cti_op_new_error);
     stubCall.addArgument(Imm32(currentInstruction[2].u.operand));
-    stubCall.addArgument(ImmPtr(JSValue::encode(m_codeBlock->unexpectedConstant(currentInstruction[3].u.operand))));
+    stubCall.addArgument(ImmPtr(JSValue::encode(m_codeBlock->getConstant(currentInstruction[3].u.operand))));
     stubCall.addArgument(Imm32(m_bytecodeIndex));
     stubCall.call(currentInstruction[1].u.operand);
@@ -829 +822 @@
     // registers to zap stale pointers, to avoid unnecessarily prolonging
     // object lifetime and increasing GC pressure.
-    size_t count = m_codeBlock->m_numVars + m_codeBlock->numberOfConstantRegisters();
+    size_t count = m_codeBlock->m_numVars;
     for (size_t j = 0; j < count; ++j)
         emitInitRegister(j);
@@ -840 +833 @@
     // registers to zap stale pointers, to avoid unnecessarily prolonging
     // object lifetime and increasing GC pressure.
-    size_t count = m_codeBlock->m_numVars + m_codeBlock->numberOfConstantRegisters();
+    size_t count = m_codeBlock->m_numVars;
     for (size_t j = 0; j < count; ++j)
         emitInitRegister(j);

trunk/JavaScriptCore/parser/Nodes.cpp

@@ -602 +602 @@
 {
     if (generator.registerFor(m_ident))
-        return generator.emitUnexpectedLoad(generator.finalDestination(dst), false);
+        return generator.emitLoad(generator.finalDestination(dst), false);
 
     generator.emitExpressionInfo(divot(), startOffset(), endOffset());
@@ -637 +637 @@
 
     // delete on a non-location expression ignores the value and returns true
-    return generator.emitUnexpectedLoad(generator.finalDestination(dst), true);
+    return generator.emitLoad(generator.finalDestination(dst), true);
 }
 
@@ -689 +689 @@
             if (dst == generator.ignoredResult())
                 return 0;
-            RefPtr<RegisterID> r0 = generator.emitUnexpectedLoad(generator.finalDestination(dst), (m_operator == OpPlusPlus) ? 1.0 : -1.0);
+            RefPtr<RegisterID> r0 = generator.emitLoad(generator.finalDestination(dst), (m_operator == OpPlusPlus) ? 1.0 : -1.0);
             return generator.emitBinaryOp(op_add, r0.get(), local, r0.get(), OperandTypes());
         }

trunk/JavaScriptCore/runtime/JSActivation.cpp

@@ -41 +41 @@
 
 JSActivation::JSActivation(CallFrame* callFrame, PassRefPtr<FunctionBodyNode> functionBody)
-    : Base(callFrame->globalData().activationStructure, new JSActivationData(functionBody, callFrame))
+    : Base(callFrame->globalData().activationStructure, new JSActivationData(functionBody, callFrame->registers()))
 {
 }

trunk/JavaScriptCore/wtf/Platform.h

@@ -549 +549 @@
 #endif
 
+#if ENABLE(JIT)
 #ifndef ENABLE_JIT_OPTIMIZE_CALL
 #define ENABLE_JIT_OPTIMIZE_CALL 1
@@ -563 +564 @@
 #ifndef ENABLE_JIT_OPTIMIZE_METHOD_CALLS
 #define ENABLE_JIT_OPTIMIZE_METHOD_CALLS 1
+#endif
 #endif
 

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2009-07-07  Gavin Barraclough  <[email protected]>
+
+        Reviewed by Geoff Garen.
+
+        fast/js/global-recursion-on-full-stack.html is a little finicky.
+
+        The test recurses down the JS stack to find the bottom (catching this with an exception),
+        then tries to call a host function (document.write), switch writes new '<script>' code,
+        and expects this code to be run, then expects this code to try to call 'f();' again,
+        which it expects to fail, and it expects to catch that exception.  However it is possible
+        that one of the earlier stages (the call to document.write, entering the interpreter to
+        run the new global code) will fail, depending on exactly how much stack space was free at
+        the point the last call to f() failed.
+
+        Tweak the test to make it work.
+
+        * fast/js/global-recursion-on-full-stack.html:
+
 2009-07-07  Dan Bernstein  <[email protected]>
 

trunk/LayoutTests/fast/js/global-recursion-on-full-stack.html

@@ -7 +7 @@
 var depth = 0;
 function f(a,b,c,d,e) {
-    var a, b, c, d, e, g;
+    var a, b, c, d, e;
     try {
         depth++;