Changeset 35203 in webkit

Timestamp:

Jul 16, 2008, 3:47:32 PM (17 years ago)

Author:

ggaren@apple.com

Message:

JavaScriptCore:

2008-07-16 Geoffrey Garen <​ggaren@apple.com>

Reviewed by Oliver Hunt.

First step toward putting doubles in registers: Turned Register into a
proper abstraction layer. It is no longer possible to cast a Register
to a JSValue*, or a Register& to a JSValue*&, or to access the union
inside a Register directly.

SunSpider reports no change.

In support of this change, I had to make the following mechanical changes
in a lot of places:

1. Clients now use explicit accessors to read data out of Registers, and implicit copy constructors to write data into registers.

So, assignment that used to look like

x.u.jsValue = y;

now looks like

x = y;

And access that used to look like

x = y.u.jsValue;

now looks like

x = y.jsValue();

2. I made generic flow control specific in opcodes that made their flow control generic by treating a Register& as a JSValue*&. This had the added benefit of removing some exception checking branches from immediate number code.

3. I beefed up PropertySlot to support storing a Register* in a property slot. For now, only JSVariableObject's symbolTableGet and symbolTablePut use this functionality, but I expect more clients to use it in the future.

4. I changed ArgList to be a buffer of Registers, not JSValue*'s, and I changed ArgList iterator clients to iterate Registers, not JSValue*'s.

WebCore:

2008-07-16 Geoffrey Garen <​ggaren@apple.com>

Reviewed by Oliver Hunt.

Support for JavaScriptCore's first step toward putting doubles in
registers: Treat ArgList iterators as Register*'s, not JSValue*'s.

• bindings/js/ScheduledAction.cpp: (WebCore::ScheduledAction::ScheduledAction):

Location:

trunk

Files:

• JavaScriptCore/ChangeLog (modified) (1 diff)
• JavaScriptCore/VM/Machine.cpp (modified) (100 diffs)
• JavaScriptCore/VM/Machine.h (modified) (1 diff)
• JavaScriptCore/VM/Register.h (modified) (4 diffs)
• JavaScriptCore/kjs/ArgList.cpp (modified) (1 diff)
• JavaScriptCore/kjs/ArgList.h (modified) (5 diffs)
• JavaScriptCore/kjs/Arguments.cpp (modified) (1 diff)
• JavaScriptCore/kjs/ArrayPrototype.cpp (modified) (1 diff)
• JavaScriptCore/kjs/DebuggerCallFrame.cpp (modified) (3 diffs)
• JavaScriptCore/kjs/IndexToNameMap.cpp (modified) (1 diff)
• JavaScriptCore/kjs/JSActivation.cpp (modified) (1 diff)
• JavaScriptCore/kjs/JSArray.cpp (modified) (1 diff)
• JavaScriptCore/kjs/JSGlobalObject.h (modified) (1 diff)
• JavaScriptCore/kjs/JSString.h (modified) (1 diff)
• JavaScriptCore/kjs/JSValue.h (modified) (3 diffs)
• JavaScriptCore/kjs/JSVariableObject.cpp (modified) (1 diff)
• JavaScriptCore/kjs/JSVariableObject.h (modified) (5 diffs)
• JavaScriptCore/kjs/PropertySlot.h (modified) (7 diffs)
• JavaScriptCore/kjs/StringConstructor.cpp (modified) (1 diff)
• JavaScriptCore/kjs/StringPrototype.cpp (modified) (1 diff)
• WebCore/ChangeLog (modified) (1 diff)
• WebCore/bindings/js/ScheduledAction.cpp (modified) (1 diff)

trunk/JavaScriptCore/ChangeLog

@@ +1 @@
+2008-07-16  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Oliver Hunt.
+        
+        First step toward putting doubles in registers: Turned Register into a
+        proper abstraction layer. It is no longer possible to cast a Register
+        to a JSValue*, or a Register& to a JSValue*&, or to access the union
+        inside a Register directly.
+        
+        SunSpider reports no change.
+        
+        In support of this change, I had to make the following mechanical changes
+        in a lot of places:
+        
+        1. Clients now use explicit accessors to read data out of Registers, and
+        implicit copy constructors to write data into registers.
+        
+        So, assignment that used to look like
+        
+            x.u.jsValue = y;
+        
+        now looks like
+        
+            x = y;
+            
+        And access that used to look like
+        
+            x = y.u.jsValue;
+        
+        now looks like
+        
+            x = y.jsValue();
+
+        2. I made generic flow control specific in opcodes that made their flow
+        control generic by treating a Register& as a JSValue*&. This had the
+        added benefit of removing some exception checking branches from immediate
+        number code.
+
+        3. I beefed up PropertySlot to support storing a Register* in a property
+        slot. For now, only JSVariableObject's symbolTableGet and symbolTablePut
+        use this functionality, but I expect more clients to use it in the future.
+        
+        4. I changed ArgList to be a buffer of Registers, not JSValue*'s, and I
+        changed ArgList iterator clients to iterate Registers, not JSValue*'s.
+
 2008-07-16  Ada Chan  <adachan@apple.com>
 

trunk/JavaScriptCore/VM/Machine.cpp

@@ -215 +215 @@
             if (exceptionValue)
                 return false;
-            r[dst].u.jsValue = result;
+            r[dst] = result;
             return true;
         }
@@ -245 +245 @@
             if (exceptionValue)
                 return false;
-            r[dst].u.jsValue = result;
+            r[dst] = result;
             return true;
         }
@@ -270 +270 @@
         base = *iter;
         if (next == end || base->getPropertySlot(exec, ident, slot)) {
-            r[dst].u.jsValue = base;
+            r[dst] = base;
             return;
         }
@@ -301 +301 @@
             if (exceptionValue)
                 return false;
-            r[propDst].u.jsValue = result;
-            r[baseDst].u.jsValue = base;
+            r[propDst] = result;
+            r[baseDst] = base;
             return true;
         }
@@ -344 +344 @@
                 return false;
 
-            r[baseDst].u.jsValue = thisObj;
-            r[funcDst].u.jsValue = result;
+            r[baseDst] = thisObj;
+            r[funcDst] = result;
             return true;
         }
@@ -355 +355 @@
 }
 
-ALWAYS_INLINE void initializeCallFrame(Register* callFrame, CodeBlock* codeBlock, Instruction* vPC, ScopeChainNode* scopeChain, Register* r, int returnValueRegister, int argv, int argc, int calledAsConstructor, JSValue* function)
-{
-    callFrame[RegisterFile::CallerCodeBlock].u.codeBlock = codeBlock;
-    callFrame[RegisterFile::ReturnVPC].u.vPC = vPC + 1;
-    callFrame[RegisterFile::CallerScopeChain].u.scopeChain = scopeChain;
-    callFrame[RegisterFile::CallerRegisters].u.r = r;
-    callFrame[RegisterFile::ReturnValueRegister].u.i = returnValueRegister;
-    callFrame[RegisterFile::ArgumentStartRegister].u.i = argv; // original argument vector (for the sake of the "arguments" object)
-    callFrame[RegisterFile::ArgumentCount].u.i = argc; // original argument count (for the sake of the "arguments" object)
-    callFrame[RegisterFile::CalledAsConstructor].u.i = calledAsConstructor;
-    callFrame[RegisterFile::Callee].u.jsValue = function;
-    callFrame[RegisterFile::OptionalCalleeActivation].u.jsValue = 0;
+ALWAYS_INLINE void Machine::initializeCallFrame(Register* callFrame, CodeBlock* codeBlock, Instruction* vPC, ScopeChainNode* scopeChain, Register* r, int returnValueRegister, int argv, int argc, int calledAsConstructor, JSValue* function)
+{
+    callFrame[RegisterFile::CallerCodeBlock] = codeBlock;
+    callFrame[RegisterFile::ReturnVPC] = vPC + 1;
+    callFrame[RegisterFile::CallerScopeChain] = scopeChain;
+    callFrame[RegisterFile::CallerRegisters] = r;
+    callFrame[RegisterFile::ReturnValueRegister] = returnValueRegister;
+    callFrame[RegisterFile::ArgumentStartRegister] = argv; // original argument vector (for the sake of the "arguments" object)
+    callFrame[RegisterFile::ArgumentCount] = argc; // original argument count (for the sake of the "arguments" object)
+    callFrame[RegisterFile::CalledAsConstructor] = calledAsConstructor;
+    callFrame[RegisterFile::Callee] = function;
+    callFrame[RegisterFile::OptionalCalleeActivation] = 0;
 }
 
@@ -390 +390 @@
         Register* endOfParams = r - newCodeBlock->numVars;
         for (Register* it = endOfParams - omittedArgCount; it != endOfParams; ++it)
-            (*it).u.jsValue = jsUndefined();
+            (*it) = jsUndefined();
     } else { // too many arguments -- copy return info and expected arguments, leaving the extra arguments behind
         int shift = argc + RegisterFile::CallFrameHeaderSize;
@@ -410 +410 @@
     // initialize local variable slots
     for (Register* it = r - newCodeBlock->numVars; it != r; ++it)
-        (*it).u.jsValue = jsUndefined();
+        (*it) = jsUndefined();
 
     return r;
@@ -419 +419 @@
     if (newCodeBlock->needsFullScopeChain) {
         JSActivation* activation = new (exec) JSActivation(functionBodyNode, r);
-        r[RegisterFile::OptionalCalleeActivation - RegisterFile::CallFrameHeaderSize - newCodeBlock->numLocals].u.jsValue = activation;
+        r[RegisterFile::OptionalCalleeActivation - RegisterFile::CallFrameHeaderSize - newCodeBlock->numLocals] = activation;
 
         return callDataScopeChain->copy()->push(activation);
@@ -435 +435 @@
 }
 
-NEVER_INLINE JSValue* callEval(ExecState* exec, JSObject* thisObj, ScopeChainNode* scopeChain, RegisterFile* registerFile, Register* r, int argv, int argc, JSValue*& exceptionValue)
+NEVER_INLINE JSValue* Machine::callEval(ExecState* exec, JSObject* thisObj, ScopeChainNode* scopeChain, RegisterFile* registerFile, Register* r, int argv, int argc, JSValue*& exceptionValue)
 {
     if (argc < 2)
         return jsUndefined();
 
-    JSValue* program = r[argv + 1].u.jsValue;
+    JSValue* program = r[argv + 1].jsValue();
 
     if (!program->isString())
@@ -515 +515 @@
         end = it + registerFile->numGlobals();
         while (it != end) {
-            printf("[global var]               | %10p | %10p \n", it, (*it).u.jsValue);
+            printf("[global var]               | %10p | %10p \n", it, (*it).jsValue());
             ++it;
         }
@@ -522 +522 @@
     
     it = r - codeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
-    printf("[CallerCodeBlock]          | %10p | %10p \n", it, (*it).u.jsValue); ++it;
-    printf("[ReturnVPC]                | %10p | %10p \n", it, (*it).u.jsValue); ++it;
-    printf("[CallerScopeChain]         | %10p | %10p \n", it, (*it).u.jsValue); ++it;
-    printf("[CallerRegisterOffset]     | %10p | %10p \n", it, (*it).u.jsValue); ++it;
-    printf("[ReturnValueRegister]      | %10p | %10p \n", it, (*it).u.jsValue); ++it;
-    printf("[ArgumentStartRegister]    | %10p | %10p \n", it, (*it).u.jsValue); ++it;
-    printf("[ArgumentCount]            | %10p | %10p \n", it, (*it).u.jsValue); ++it;
-    printf("[CalledAsConstructor]      | %10p | %10p \n", it, (*it).u.jsValue); ++it;
-    printf("[Callee]                   | %10p | %10p \n", it, (*it).u.jsValue); ++it;
-    printf("[OptionalCalleeActivation] | %10p | %10p \n", it, (*it).u.jsValue); ++it;
+    printf("[CallerCodeBlock]          | %10p | %10p \n", it, (*it).jsValue()); ++it;
+    printf("[ReturnVPC]                | %10p | %10p \n", it, (*it).jsValue()); ++it;
+    printf("[CallerScopeChain]         | %10p | %10p \n", it, (*it).jsValue()); ++it;
+    printf("[CallerRegisterOffset]     | %10p | %10p \n", it, (*it).jsValue()); ++it;
+    printf("[ReturnValueRegister]      | %10p | %10p \n", it, (*it).jsValue()); ++it;
+    printf("[ArgumentStartRegister]    | %10p | %10p \n", it, (*it).jsValue()); ++it;
+    printf("[ArgumentCount]            | %10p | %10p \n", it, (*it).jsValue()); ++it;
+    printf("[CalledAsConstructor]      | %10p | %10p \n", it, (*it).jsValue()); ++it;
+    printf("[Callee]                   | %10p | %10p \n", it, (*it).jsValue()); ++it;
+    printf("[OptionalCalleeActivation] | %10p | %10p \n", it, (*it).jsValue()); ++it;
     printf("----------------------------------------------------\n");
 
-    printf("[this]                     | %10p | %10p \n", it, (*it).u.jsValue); ++it;
+    printf("[this]                     | %10p | %10p \n", it, (*it).jsValue()); ++it;
     end = it + max(codeBlock->numParameters - 1, 0); // - 1 to skip "this"
     if (it != end) {
         do {
-            printf("[param]                    | %10p | %10p \n", it, (*it).u.jsValue);
+            printf("[param]                    | %10p | %10p \n", it, (*it).jsValue());
             ++it;
         } while (it != end);
@@ -548 +548 @@
         if (it != end) {
             do {
-                printf("[var]                      | %10p | %10p \n", it, (*it).u.jsValue);
+                printf("[var]                      | %10p | %10p \n", it, (*it).jsValue());
                 ++it;
             } while (it != end);
@@ -558 +558 @@
     if (it != end) {
         do {
-            printf("[temp]                     | %10p | %10p \n", it, (*it).u.jsValue);
+            printf("[temp]                     | %10p | %10p \n", it, (*it).jsValue());
             ++it;
         } while (it != end);
@@ -582 +582 @@
     if (Debugger* debugger = exec->dynamicGlobalObject()->debugger()) {
         DebuggerCallFrame debuggerCallFrame(exec->dynamicGlobalObject(), codeBlock, scopeChain, r, exceptionValue);
-        if (callFrame[RegisterFile::Callee].u.jsObject)
+        if (callFrame[RegisterFile::Callee].jsValue())
             debugger->returnEvent(debuggerCallFrame, codeBlock->ownerNode->sourceId(), codeBlock->ownerNode->lastLine());
         else
@@ -589 +589 @@
 
     if (Profiler* profiler = *Profiler::enabledProfilerReference()) {
-        if (callFrame[RegisterFile::Callee].u.jsObject)
-            profiler->didExecute(exec, callFrame[RegisterFile::Callee].u.jsObject);
+        if (callFrame[RegisterFile::Callee].jsValue())
+            profiler->didExecute(exec, static_cast<JSObject*>(callFrame[RegisterFile::Callee].jsValue()));
         else
             profiler->didExecute(exec, codeBlock->ownerNode->sourceURL(), codeBlock->ownerNode->lineNo());
@@ -599 +599 @@
 
     // If this call frame created an activation, tear it off.
-    if (JSActivation* activation = static_cast<JSActivation*>(callFrame[RegisterFile::OptionalCalleeActivation].u.jsValue)) {
+    if (JSActivation* activation = static_cast<JSActivation*>(callFrame[RegisterFile::OptionalCalleeActivation].jsValue())) {
         ASSERT(activation->isActivationObject());
         activation->copyRegisters();
     }
     
-    codeBlock = callFrame[RegisterFile::CallerCodeBlock].u.codeBlock;
+    codeBlock = callFrame[RegisterFile::CallerCodeBlock].codeBlock();
     if (!codeBlock)
         return false;
 
     k = codeBlock->jsValues.data();
-    scopeChain = callFrame[RegisterFile::CallerScopeChain].u.scopeChain;
-    r = callFrame[RegisterFile::CallerRegisters].u.r;
+    scopeChain = callFrame[RegisterFile::CallerScopeChain].scopeChain();
+    r = callFrame[RegisterFile::CallerRegisters].r();
     exec->m_callFrame = r - oldCodeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
-    vPC = callFrame[RegisterFile::ReturnVPC].u.vPC;
+    vPC = callFrame[RegisterFile::ReturnVPC].vPC();
 
     return true;
@@ -689 +689 @@
 
     Register* r = callFrame + RegisterFile::CallFrameHeaderSize + codeBlock->numVars;
-    r[codeBlock->thisRegister].u.jsValue = thisObj;
+    r[codeBlock->thisRegister] = thisObj;
 
     if (codeBlock->needsFullScopeChain)
@@ -737 +737 @@
     // put args in place, including "this"
     Register* dst = callFrame + RegisterFile::CallFrameHeaderSize;
-    (*dst).u.jsValue = thisObj;
+    (*dst) = thisObj;
 
     ArgList::const_iterator end = args.end();
     for (ArgList::const_iterator it = args.begin(); it != end; ++it)
-        (*++dst).u.jsValue = *it;
+        (*++dst) = *it;
 
     // a 0 codeBlock indicates a built-in caller
@@ -816 +816 @@
 
     Register* r = callFrame + RegisterFile::CallFrameHeaderSize + codeBlock->numVars;
-    r[codeBlock->thisRegister].u.jsValue = thisObj;
+    r[codeBlock->thisRegister] = thisObj;
 
     if (codeBlock->needsFullScopeChain)
@@ -1027 +1027 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        r[dst].u.jsValue = k[src];
+        r[dst] = k[src];
 
         ++vPC;
@@ -1039 +1039 @@
         */
         int dst = (++vPC)->u.operand;
-        r[dst].u.jsValue = constructEmptyObject(exec);
+        r[dst] = constructEmptyObject(exec);
 
         ++vPC;
@@ -1055 +1055 @@
         int firstArg = (++vPC)->u.operand;
         int argCount = (++vPC)->u.operand;
-        ArgList args(reinterpret_cast<JSValue**>(r) + firstArg, argCount);
-        r[dst].u.jsValue = constructArray(exec, args);
+        ArgList args(r + firstArg, argCount);
+        r[dst] = constructArray(exec, args);
 
         ++vPC;
@@ -1070 +1070 @@
         int dst = (++vPC)->u.operand;
         int regExp = (++vPC)->u.operand;
-        r[dst].u.jsValue = new (exec) RegExpObject(scopeChain->globalObject()->regExpPrototype(), codeBlock->regexps[regExp]);
+        r[dst] = new (exec) RegExpObject(scopeChain->globalObject()->regExpPrototype(), codeBlock->regexps[regExp]);
 
         ++vPC;
@@ -1094 +1094 @@
            as a boolean in register dst.
         */
-        JSValue*& dst = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src1 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src2 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* result;
+        int dst = (++vPC)->u.operand;
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue();
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue();
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            result = jsBoolean(reinterpret_cast<intptr_t>(src1) == reinterpret_cast<intptr_t>(src2));
+            r[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) == reinterpret_cast<intptr_t>(src2));
         else {
-            result = jsBoolean(equal(exec, src1, src2));
+            JSValue* result = jsBoolean(equal(exec, src1, src2));
             VM_CHECK_EXCEPTION();
-        }
-        dst = result;
+            r[dst] = result;
+        }
 
         ++vPC;
@@ -1116 +1115 @@
            result as a boolean in register dst.
         */
-        JSValue*& dst = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src1 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src2 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* result;
+        int dst = (++vPC)->u.operand;
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue();
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue();
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            result = jsBoolean(reinterpret_cast<intptr_t>(src1) != reinterpret_cast<intptr_t>(src2));
+            r[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) != reinterpret_cast<intptr_t>(src2));
         else {
-            result = jsBoolean(!equal(exec, src1, src2));
+            JSValue* result = jsBoolean(!equal(exec, src1, src2));
             VM_CHECK_EXCEPTION();
-        }
-        dst = result;
+            r[dst] = result;
+        }
 
         ++vPC;
@@ -1138 +1136 @@
            result as a boolean in register dst.
         */
-        JSValue*& dst = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src1 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src2 = r[(++vPC)->u.operand].u.jsValue;
+        int dst = (++vPC)->u.operand;
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue();
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue();
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            dst = jsBoolean(reinterpret_cast<intptr_t>(src1) == reinterpret_cast<intptr_t>(src2));
+            r[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) == reinterpret_cast<intptr_t>(src2));
         else
-            dst = jsBoolean(strictEqual(src1, src2));
+            r[dst] = jsBoolean(strictEqual(src1, src2));
 
         ++vPC;
@@ -1156 +1154 @@
            puts the result as a boolean in register dst.
         */
-        JSValue*& dst = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src1 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src2 = r[(++vPC)->u.operand].u.jsValue;
+        int dst = (++vPC)->u.operand;
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue();
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue();
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            dst = jsBoolean(reinterpret_cast<intptr_t>(src1) != reinterpret_cast<intptr_t>(src2));
+            r[dst] = jsBoolean(reinterpret_cast<intptr_t>(src1) != reinterpret_cast<intptr_t>(src2));
         else
-            dst = jsBoolean(!strictEqual(src1, src2));
+            r[dst] = jsBoolean(!strictEqual(src1, src2));
 
         ++vPC;
@@ -1174 +1172 @@
            a boolean in register dst.
         */
-        JSValue*& dst = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src1 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src2 = r[(++vPC)->u.operand].u.jsValue;
+        int dst = (++vPC)->u.operand;
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue();
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue();
         JSValue* result = jsBoolean(jsLess(exec, src1, src2));
         VM_CHECK_EXCEPTION();
-        dst = result;
+        r[dst] = result;
 
         ++vPC;
@@ -1191 +1189 @@
            puts the result as a boolean in register dst.
         */
-        JSValue*& dst = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src1 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src2 = r[(++vPC)->u.operand].u.jsValue;
+        int dst = (++vPC)->u.operand;
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue();
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue();
         JSValue* result = jsBoolean(jsLessEq(exec, src1, src2));
         VM_CHECK_EXCEPTION();
-        dst = result;
+        r[dst] = result;
 
         ++vPC;
@@ -1208 +1206 @@
         */
         int srcDst = (++vPC)->u.operand;
-        JSValue* v = r[srcDst].u.jsValue;
-        JSValue* result;
+        JSValue* v = r[srcDst].jsValue();
         if (JSImmediate::canDoFastAdditiveOperations(v))
-            result = JSImmediate::incImmediateNumber(v);
-        else
-            result = jsNumber(exec, v->toNumber(exec) + 1);
-        VM_CHECK_EXCEPTION();
-        r[srcDst].u.jsValue = result;
+            r[srcDst] = JSImmediate::incImmediateNumber(v);
+        else {
+            JSValue* result = jsNumber(exec, v->toNumber(exec) + 1);
+            VM_CHECK_EXCEPTION();
+            r[srcDst] = result;
+        }
 
         ++vPC;
@@ -1227 +1225 @@
         */
         int srcDst = (++vPC)->u.operand;
-        JSValue* v = r[srcDst].u.jsValue;
-        JSValue* result;
+        JSValue* v = r[srcDst].jsValue();
         if (JSImmediate::canDoFastAdditiveOperations(v))
-            result = JSImmediate::decImmediateNumber(v);
-        else
-            result = jsNumber(exec, v->toNumber(exec) - 1);
-        VM_CHECK_EXCEPTION();
-        r[srcDst].u.jsValue = result;
+            r[srcDst] = JSImmediate::decImmediateNumber(v);
+        else {
+            JSValue* result = jsNumber(exec, v->toNumber(exec) - 1);
+            VM_CHECK_EXCEPTION();
+            r[srcDst] = result;
+        }
 
         ++vPC;
@@ -1248 +1246 @@
         int dst = (++vPC)->u.operand;
         int srcDst = (++vPC)->u.operand;
-        JSValue* v = r[srcDst].u.jsValue;
-        JSValue* result;
-        JSValue* number;
+        JSValue* v = r[srcDst].jsValue();
         if (JSImmediate::canDoFastAdditiveOperations(v)) {
-            number = v;
-            result = JSImmediate::incImmediateNumber(v);
+            r[dst] = v;
+            r[srcDst] = JSImmediate::incImmediateNumber(v);
         } else {
-            number = r[srcDst].u.jsValue->toJSNumber(exec);
-            result = jsNumber(exec, number->uncheckedGetNumber() + 1);
-        }
-        VM_CHECK_EXCEPTION();
-
-        r[dst].u.jsValue = number;
-        r[srcDst].u.jsValue = result;
+            JSValue* number = r[srcDst].jsValue()->toJSNumber(exec);
+            VM_CHECK_EXCEPTION();
+            r[dst] = number;
+            r[srcDst] = jsNumber(exec, number->uncheckedGetNumber() + 1);
+        }
 
         ++vPC;
@@ -1275 +1269 @@
         int dst = (++vPC)->u.operand;
         int srcDst = (++vPC)->u.operand;
-        JSValue* v = r[srcDst].u.jsValue;
-        JSValue* result;
-        JSValue* number;
+        JSValue* v = r[srcDst].jsValue();
         if (JSImmediate::canDoFastAdditiveOperations(v)) {
-            number = v;
-            result = JSImmediate::decImmediateNumber(v);
+            r[dst] = v;
+            r[srcDst] = JSImmediate::decImmediateNumber(v);
         } else {
-            number = r[srcDst].u.jsValue->toJSNumber(exec);
-            result = jsNumber(exec, number->uncheckedGetNumber() - 1);
-        }
-        VM_CHECK_EXCEPTION();
-
-        r[dst].u.jsValue = number;
-        r[srcDst].u.jsValue = result;
+            JSValue* number = r[srcDst].jsValue()->toJSNumber(exec);
+            VM_CHECK_EXCEPTION();
+            r[dst] = number;
+            r[srcDst] = jsNumber(exec, number->uncheckedGetNumber() - 1);
+        }
 
         ++vPC;
@@ -1301 +1291 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        JSValue* result = r[src].u.jsValue->toJSNumber(exec);
+        JSValue* result = r[src].jsValue()->toJSNumber(exec);
         VM_CHECK_EXCEPTION();
 
-        r[dst].u.jsValue = result;
+        r[dst] = result;
 
         ++vPC;
@@ -1317 +1307 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        JSValue* result = jsNumber(exec, -r[src].u.jsValue->toNumber(exec));
+        JSValue* result = jsNumber(exec, -r[src].jsValue()->toNumber(exec));
         VM_CHECK_EXCEPTION();
-        r[dst].u.jsValue = result;
+        r[dst] = result;
 
         ++vPC;
@@ -1331 +1321 @@
            numeric add, depending on the types of the operands.)
         */
-        JSValue*& dst = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src1 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src2 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* result;
+        int dst = (++vPC)->u.operand;
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue();
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue();
         if (JSImmediate::canDoFastAdditiveOperations(src1) && JSImmediate::canDoFastAdditiveOperations(src2))
-            result = JSImmediate::addImmediateNumbers(src1, src2);
+            r[dst] = JSImmediate::addImmediateNumbers(src1, src2);
         else {
-            result = jsAdd(exec, src1, src2);
+            JSValue* result = jsAdd(exec, src1, src2);
             VM_CHECK_EXCEPTION();
-        }
-        dst = result;
+            r[dst] = result;
+        }
         ++vPC;
         NEXT_OPCODE;
@@ -1351 +1340 @@
            numbers), and puts the product in register dst.
         */
-        JSValue*& dst = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src1 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src2 = r[(++vPC)->u.operand].u.jsValue;
+        int dst = (++vPC)->u.operand;
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue();
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue();
         JSValue* result = jsNumber(exec, src1->toNumber(exec) * src2->toNumber(exec));
         VM_CHECK_EXCEPTION();
-        dst = result;
+        r[dst] = result;
 
         ++vPC;
@@ -1371 +1360 @@
         int dividend = (++vPC)->u.operand;
         int divisor = (++vPC)->u.operand;
-        JSValue* result = jsNumber(exec, r[dividend].u.jsValue->toNumber(exec) / r[divisor].u.jsValue->toNumber(exec));
+        JSValue* result = jsNumber(exec, r[dividend].jsValue()->toNumber(exec) / r[divisor].jsValue()->toNumber(exec));
         VM_CHECK_EXCEPTION();
-        r[dst].u.jsValue = result;
+        r[dst] = result;
         ++vPC;
         NEXT_OPCODE;
@@ -1387 +1376 @@
         int dividend = (++vPC)->u.operand;
         int divisor = (++vPC)->u.operand;
-        double d = r[dividend].u.jsValue->toNumber(exec);
-        JSValue* result = jsNumber(exec, fmod(d, r[divisor].u.jsValue->toNumber(exec)));
+        double d = r[dividend].jsValue()->toNumber(exec);
+        JSValue* result = jsNumber(exec, fmod(d, r[divisor].jsValue()->toNumber(exec)));
         VM_CHECK_EXCEPTION();
-        r[dst].u.jsValue = result;
+        r[dst] = result;
         ++vPC;
         NEXT_OPCODE;
@@ -1401 +1390 @@
            register dst.
         */
-        JSValue*& dst = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src1 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src2 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* result;
+        int dst = (++vPC)->u.operand;
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue();
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue();
         if (JSImmediate::canDoFastAdditiveOperations(src1) && JSImmediate::canDoFastAdditiveOperations(src2))
-            result = JSImmediate::subImmediateNumbers(src1, src2);
+            r[dst] = JSImmediate::subImmediateNumbers(src1, src2);
         else {
-            result = jsNumber(exec, src1->toNumber(exec) - src2->toNumber(exec));
+            JSValue* result = jsNumber(exec, src1->toNumber(exec) - src2->toNumber(exec));
             VM_CHECK_EXCEPTION();
-        }
-        dst = result;
+            r[dst] = result;
+        }
         ++vPC;
         NEXT_OPCODE;
@@ -1422 +1410 @@
            in register dst.
         */
-        JSValue*& dst = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* val = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* shift = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* result;
+        int dst = (++vPC)->u.operand;
+        JSValue* val = r[(++vPC)->u.operand].jsValue();
+        JSValue* shift = r[(++vPC)->u.operand].jsValue();
         if (JSImmediate::areBothImmediateNumbers(val, shift))
-            result = jsNumber(exec, JSImmediate::getTruncatedInt32(val) << (JSImmediate::toTruncatedUInt32(shift) & 0x1f));
+            r[dst] = jsNumber(exec, JSImmediate::getTruncatedInt32(val) << (JSImmediate::toTruncatedUInt32(shift) & 0x1f));
         else {
-            result = jsNumber(exec, (val->toInt32(exec)) << (shift->toUInt32(exec) & 0x1f));
+            JSValue* result = jsNumber(exec, (val->toInt32(exec)) << (shift->toUInt32(exec) & 0x1f));
             VM_CHECK_EXCEPTION();
-        }
-        dst = result;
+            r[dst] = result;
+        }
 
         ++vPC;
@@ -1444 +1431 @@
            uint32), and puts the result in register dst.
         */
-        JSValue*& dst = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* val = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* shift = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* result;
+        int dst = (++vPC)->u.operand;
+        JSValue* val = r[(++vPC)->u.operand].jsValue();
+        JSValue* shift = r[(++vPC)->u.operand].jsValue();
         if (JSImmediate::areBothImmediateNumbers(val, shift))
-            result = JSImmediate::rightShiftImmediateNumbers(val, shift);
+            r[dst] = JSImmediate::rightShiftImmediateNumbers(val, shift);
         else {
-            result = jsNumber(exec, (val->toInt32(exec)) >> (shift->toUInt32(exec) & 0x1f));
+            JSValue* result = jsNumber(exec, (val->toInt32(exec)) >> (shift->toUInt32(exec) & 0x1f));
             VM_CHECK_EXCEPTION();
-        }
-        dst = result;
+            r[dst] = result;
+        }
 
         ++vPC;
@@ -1466 +1452 @@
            uint32), and puts the result in register dst.
         */
-        JSValue*& dst = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* val = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* shift = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* result;
+        int dst = (++vPC)->u.operand;
+        JSValue* val = r[(++vPC)->u.operand].jsValue();
+        JSValue* shift = r[(++vPC)->u.operand].jsValue();
         if (JSImmediate::areBothImmediateNumbers(val, shift) && !JSImmediate::isNegative(val))
-            result = JSImmediate::rightShiftImmediateNumbers(val, shift);
+            r[dst] = JSImmediate::rightShiftImmediateNumbers(val, shift);
         else {
-            result = jsNumber(exec, (val->toUInt32(exec)) >> (shift->toUInt32(exec) & 0x1f));
+            JSValue* result = jsNumber(exec, (val->toUInt32(exec)) >> (shift->toUInt32(exec) & 0x1f));
             VM_CHECK_EXCEPTION();
-        }
-        dst = result;
+            r[dst] = result;
+        }
 
         ++vPC;
@@ -1488 +1473 @@
            in register dst.
         */
-        JSValue*& dst = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src1 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src2 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* result;
+        int dst = (++vPC)->u.operand;
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue();
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue();
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            result = JSImmediate::andImmediateNumbers(src1, src2);
+            r[dst] = JSImmediate::andImmediateNumbers(src1, src2);
         else {
-            result = jsNumber(exec, src1->toInt32(exec) & src2->toInt32(exec));
+            JSValue* result = jsNumber(exec, src1->toInt32(exec) & src2->toInt32(exec));
             VM_CHECK_EXCEPTION();
-        }
-        dst = result;
+            r[dst] = result;
+        }
 
         ++vPC;
@@ -1510 +1494 @@
            in register dst.
         */
-        JSValue*& dst = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src1 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src2 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* result;
+        int dst = (++vPC)->u.operand;
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue();
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue();
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            result = JSImmediate::xorImmediateNumbers(src1, src2);
+            r[dst] = JSImmediate::xorImmediateNumbers(src1, src2);
         else {
-            result = jsNumber(exec, src1->toInt32(exec) ^ src2->toInt32(exec));
+            JSValue* result = jsNumber(exec, src1->toInt32(exec) ^ src2->toInt32(exec));
             VM_CHECK_EXCEPTION();
-        }
-        dst = result;
+            r[dst] = result;
+        }
 
         ++vPC;
@@ -1532 +1515 @@
            result in register dst.
         */
-        JSValue*& dst = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src1 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src2 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* result;
+        int dst = (++vPC)->u.operand;
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue();
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue();
         if (JSImmediate::areBothImmediateNumbers(src1, src2))
-            result = JSImmediate::orImmediateNumbers(src1, src2);
+            r[dst] = JSImmediate::orImmediateNumbers(src1, src2);
         else {
-            result = jsNumber(exec, src1->toInt32(exec) | src2->toInt32(exec));
+            JSValue* result = jsNumber(exec, src1->toInt32(exec) | src2->toInt32(exec));
             VM_CHECK_EXCEPTION();
-        }
-        dst = result;
+            r[dst] = result;
+        }
 
         ++vPC;
@@ -1555 +1537 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        JSValue* result = jsNumber(exec, ~r[src].u.jsValue->toInt32(exec));
+        JSValue* result = jsNumber(exec, ~r[src].jsValue()->toInt32(exec));
         VM_CHECK_EXCEPTION();
-        r[dst].u.jsValue = result;
+        r[dst] = result;
 
         ++vPC;
@@ -1570 +1552 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        JSValue* result = jsBoolean(!r[src].u.jsValue->toBoolean(exec));
+        JSValue* result = jsBoolean(!r[src].jsValue()->toBoolean(exec));
         VM_CHECK_EXCEPTION();
-        r[dst].u.jsValue = result;
+        r[dst] = result;
 
         ++vPC;
@@ -1590 +1572 @@
         int base = (++vPC)->u.operand;
 
-        JSValue* baseVal = r[base].u.jsValue;
+        JSValue* baseVal = r[base].jsValue();
 
         if (isNotObject(exec, vPC, codeBlock, baseVal, exceptionValue))
@@ -1596 +1578 @@
 
         JSObject* baseObj = static_cast<JSObject*>(baseVal);
-        r[dst].u.jsValue = jsBoolean(baseObj->implementsHasInstance() ? baseObj->hasInstance(exec, r[value].u.jsValue) : false);
+        r[dst] = jsBoolean(baseObj->implementsHasInstance() ? baseObj->hasInstance(exec, r[value].jsValue()) : false);
 
         ++vPC;
@@ -1609 +1591 @@
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
-        r[dst].u.jsValue = jsTypeStringForValue(exec, r[src].u.jsValue);
+        r[dst] = jsTypeStringForValue(exec, r[src].jsValue());
 
         ++vPC;
@@ -1627 +1609 @@
         int base = (++vPC)->u.operand;
 
-        JSValue* baseVal = r[base].u.jsValue;
+        JSValue* baseVal = r[base].jsValue();
         if (isNotObject(exec, vPC, codeBlock, baseVal, exceptionValue))
             goto vm_throw;
@@ -1633 +1615 @@
         JSObject* baseObj = static_cast<JSObject*>(baseVal);
 
-        JSValue* propName = r[property].u.jsValue;
+        JSValue* propName = r[property].jsValue();
 
         uint32_t i;
         if (propName->getUInt32(i))
-            r[dst].u.jsValue = jsBoolean(baseObj->hasProperty(exec, i));
+            r[dst] = jsBoolean(baseObj->hasProperty(exec, i));
         else {
             Identifier property(exec, propName->toString(exec));
             VM_CHECK_EXCEPTION();
-            r[dst].u.jsValue = jsBoolean(baseObj->hasProperty(exec, property));
+            r[dst] = jsBoolean(baseObj->hasProperty(exec, property));
         }
 
@@ -1694 +1676 @@
         ASSERT((*iter)->isVariableObject());
         JSVariableObject* scope = static_cast<JSVariableObject*>(*iter);
-        r[dst].u.jsValue = scope->valueAt(index);
+        r[dst] = scope->registerAt(index);
         ++vPC;
         NEXT_OPCODE;
@@ -1716 +1698 @@
         ASSERT((*iter)->isVariableObject());
         JSVariableObject* scope = static_cast<JSVariableObject*>(*iter);
-        scope->valueAt(index) = r[value].u.jsValue;
+        scope->registerAt(index) = r[value].jsValue();
         ++vPC;
         NEXT_OPCODE;
@@ -1784 +1766 @@
 
         Identifier& ident = codeBlock->identifiers[property];
-        JSValue *result = r[base].u.jsValue->get(exec, ident);
+        JSValue *result = r[base].jsValue()->get(exec, ident);
         VM_CHECK_EXCEPTION();
-        r[dst].u.jsValue = result;
+        r[dst] = result;
         ++vPC;
         NEXT_OPCODE;
@@ -1804 +1786 @@
 
         Identifier& ident = codeBlock->identifiers[property];
-        r[base].u.jsValue->put(exec, ident, r[value].u.jsValue);
+        r[base].jsValue()->put(exec, ident, r[value].jsValue());
 
         VM_CHECK_EXCEPTION();
@@ -1822 +1804 @@
         int property = (++vPC)->u.operand;
 
-        JSObject* baseObj = r[base].u.jsValue->toObject(exec);
+        JSObject* baseObj = r[base].jsValue()->toObject(exec);
 
         Identifier& ident = codeBlock->identifiers[property];
         JSValue* result = jsBoolean(baseObj->deleteProperty(exec, ident));
         VM_CHECK_EXCEPTION();
-        r[dst].u.jsValue = result;
+        r[dst] = result;
         ++vPC;
         NEXT_OPCODE;
@@ -1843 +1825 @@
         int property = (++vPC)->u.operand;
 
-        JSValue* baseValue = r[base].u.jsValue;
-        JSValue* subscript = r[property].u.jsValue;
+        JSValue* baseValue = r[base].jsValue();
+        JSValue* subscript = r[property].jsValue();
 
         JSValue* result;
@@ -1867 +1849 @@
 
         VM_CHECK_EXCEPTION();
-        r[dst].u.jsValue = result;
+        r[dst] = result;
         ++vPC;
         NEXT_OPCODE;
@@ -1886 +1868 @@
         int value = (++vPC)->u.operand;
 
-        JSValue* baseValue = r[base].u.jsValue;
-        JSValue* subscript = r[property].u.jsValue;
+        JSValue* baseValue = r[base].jsValue();
+        JSValue* subscript = r[property].jsValue();
 
         unsigned i;
@@ -1896 +1878 @@
                 JSArray* jsArray = static_cast<JSArray*>(baseValue);
                 if (jsArray->canSetIndex(i))
-                    jsArray->setIndex(i, r[value].u.jsValue);
+                    jsArray->setIndex(i, r[value].jsValue());
                 else
-                    jsArray->JSArray::put(exec, i, r[value].u.jsValue);
+                    jsArray->JSArray::put(exec, i, r[value].jsValue());
             } else
-                baseValue->put(exec, i, r[value].u.jsValue);
+                baseValue->put(exec, i, r[value].jsValue());
         } else {
             Identifier property(exec, subscript->toString(exec));
             if (!exec->hadException()) // Don't put to an object if toString threw an exception.
-                baseValue->put(exec, property, r[value].u.jsValue);
+                baseValue->put(exec, property, r[value].jsValue());
         }
 
@@ -1923 +1905 @@
         int property = (++vPC)->u.operand;
 
-        JSObject* baseObj = r[base].u.jsValue->toObject(exec); // may throw
-
-        JSValue* subscript = r[property].u.jsValue;
+        JSObject* baseObj = r[base].jsValue()->toObject(exec); // may throw
+
+        JSValue* subscript = r[property].jsValue();
         JSValue* result;
         uint32_t i;
@@ -1938 +1920 @@
 
         VM_CHECK_EXCEPTION();
-        r[dst].u.jsValue = result;
+        r[dst] = result;
         ++vPC;
         NEXT_OPCODE;
@@ -1958 +1940 @@
         int value = (++vPC)->u.operand;
 
-        r[base].u.jsObject->put(exec, property, r[value].u.jsValue);
+        r[base].jsValue()->put(exec, property, r[value].jsValue());
 
         ++vPC;
@@ -2005 +1987 @@
         int cond = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        if (r[cond].u.jsValue->toBoolean(exec)) {
+        if (r[cond].jsValue()->toBoolean(exec)) {
             vPC += target;
             CHECK_FOR_TIMEOUT();
@@ -2022 +2004 @@
         int cond = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        if (r[cond].u.jsValue->toBoolean(exec)) {
+        if (r[cond].jsValue()->toBoolean(exec)) {
             vPC += target;
             NEXT_OPCODE;
@@ -2038 +2020 @@
         int cond = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        if (!r[cond].u.jsValue->toBoolean(exec)) {
+        if (!r[cond].jsValue()->toBoolean(exec)) {
             vPC += target;
             NEXT_OPCODE;
@@ -2057 +2039 @@
            the JS timeout is reached.
          */
-        JSValue* src1 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src2 = r[(++vPC)->u.operand].u.jsValue;
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue();
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue();
         int target = (++vPC)->u.operand;
         
@@ -2081 +2063 @@
            result of the comparison is true.
         */
-        JSValue* src1 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src2 = r[(++vPC)->u.operand].u.jsValue;
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue();
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue();
         int target = (++vPC)->u.operand;
 
@@ -2104 +2086 @@
            result of the comparison is false.
         */
-        JSValue* src1 = r[(++vPC)->u.operand].u.jsValue;
-        JSValue* src2 = r[(++vPC)->u.operand].u.jsValue;
+        JSValue* src1 = r[(++vPC)->u.operand].jsValue();
+        JSValue* src2 = r[(++vPC)->u.operand].jsValue();
         int target = (++vPC)->u.operand;
 
@@ -2130 +2112 @@
         int func = (++vPC)->u.operand;
 
-        r[dst].u.jsValue = codeBlock->functions[func]->makeFunction(exec, scopeChain);
+        r[dst] = codeBlock->functions[func]->makeFunction(exec, scopeChain);
 
         ++vPC;
@@ -2146 +2128 @@
         int func = (++vPC)->u.operand;
 
-        r[dst].u.jsValue = codeBlock->functionExpressions[func]->makeFunction(exec, scopeChain);
+        r[dst] = codeBlock->functionExpressions[func]->makeFunction(exec, scopeChain);
 
         ++vPC;
@@ -2169 +2151 @@
         int argCount = (++vPC)->u.operand;
 
-        JSValue* funcVal = r[func].u.jsValue;
-        JSValue* baseVal = r[thisVal].u.jsValue;
+        JSValue* funcVal = r[func].jsValue();
+        JSValue* baseVal = r[thisVal].jsValue();
 
         if (baseVal == scopeChain->globalObject() && funcVal == scopeChain->globalObject()->evalFunction()) {
-            JSObject* thisObject = r[codeBlock->thisRegister].u.jsObject;
+            JSObject* thisObject = static_cast<JSObject*>(r[codeBlock->thisRegister].jsValue());
             JSValue* result = callEval(exec, thisObject, scopeChain, registerFile, r, firstArg, argCount, exceptionValue);
             if (exceptionValue)
                 goto vm_throw;
 
-            r[dst].u.jsValue = result;
+            r[dst] = result;
 
             ++vPC;
@@ -2188 +2170 @@
         // value.
         vPC -= 5;
-        r[thisVal].u.jsValue = baseVal->toThisObject(exec);
+        r[thisVal] = baseVal->toThisObject(exec);
 
 #if HAVE(COMPUTED_GOTO)
@@ -2241 +2223 @@
         int argCount = (++vPC)->u.operand;
 
-        JSValue* v = r[func].u.jsValue;
+        JSValue* v = r[func].jsValue();
 
         CallData callData;
@@ -2254 +2236 @@
             CodeBlock* newCodeBlock = &functionBodyNode->code(callDataScopeChain);
 
-            r[firstArg].u.jsValue = thisVal == missingThisObjectMarker() ? exec->globalThisValue() : r[thisVal].u.jsValue;
+            r[firstArg] = thisVal == missingThisObjectMarker() ? exec->globalThisValue() : r[thisVal].jsValue();
 
             Register* callFrame = r + firstArg - RegisterFile::CallFrameHeaderSize;
@@ -2280 +2262 @@
                 (*enabledProfilerReference)->willExecute(exec, static_cast<JSObject*>(v));
 
-            JSValue* thisValue = thisVal == missingThisObjectMarker() ? exec->globalThisValue() : r[thisVal].u.jsValue;
-            ArgList args(reinterpret_cast<JSValue**>(r) + firstArg + 1, argCount - 1);
+            JSValue* thisValue = thisVal == missingThisObjectMarker() ? exec->globalThisValue() : r[thisVal].jsValue();
+            ArgList args(r + firstArg + 1, argCount - 1);
 
             JSValue* returnValue = callData.native.function(exec, static_cast<JSObject*>(v), thisValue, args);
             VM_CHECK_EXCEPTION();
 
-            r[dst].u.jsValue = returnValue;
+            r[dst] = returnValue;
 
             if (*enabledProfilerReference)
@@ -2313 +2295 @@
 
         Register* callFrame = r - codeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
-        if (JSActivation* activation = static_cast<JSActivation*>(callFrame[RegisterFile::OptionalCalleeActivation].u.jsValue)) {
+        if (JSActivation* activation = static_cast<JSActivation*>(callFrame[RegisterFile::OptionalCalleeActivation].jsValue())) {
             ASSERT(!codeBlock->needsFullScopeChain || scopeChain->object == activation);
             ASSERT(activation->isActivationObject());
@@ -2320 +2302 @@
 
         if (*enabledProfilerReference)
-            (*enabledProfilerReference)->didExecute(exec, callFrame[RegisterFile::Callee].u.jsObject);
+            (*enabledProfilerReference)->didExecute(exec, static_cast<JSObject*>(callFrame[RegisterFile::Callee].jsValue()));
 
         if (codeBlock->needsFullScopeChain)
             scopeChain->deref();
 
-        JSValue* returnValue = r[result].u.jsValue;
-        if (callFrame[RegisterFile::CalledAsConstructor].u.i && !returnValue->isObject()) {
-            JSValue* thisObject = callFrame[RegisterFile::CallFrameHeaderSize].u.jsValue;
+        JSValue* returnValue = r[result].jsValue();
+        if (callFrame[RegisterFile::CalledAsConstructor].i() && !returnValue->isObject()) {
+            JSValue* thisObject = callFrame[RegisterFile::CallFrameHeaderSize].jsValue();
             returnValue = thisObject;
         }
 
-        codeBlock = callFrame[RegisterFile::CallerCodeBlock].u.codeBlock;
+        codeBlock = callFrame[RegisterFile::CallerCodeBlock].codeBlock();
         if (!codeBlock)
             return returnValue;
 
         k = codeBlock->jsValues.data();
-        vPC = callFrame[RegisterFile::ReturnVPC].u.vPC;
-        setScopeChain(exec, scopeChain, callFrame[RegisterFile::CallerScopeChain].u.scopeChain);
-        r = callFrame[RegisterFile::CallerRegisters].u.r;
+        vPC = callFrame[RegisterFile::ReturnVPC].vPC();
+        setScopeChain(exec, scopeChain, callFrame[RegisterFile::CallerScopeChain].scopeChain());
+        r = callFrame[RegisterFile::CallerRegisters].r();
         exec->m_callFrame = r - codeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
-        int dst = callFrame[RegisterFile::ReturnValueRegister].u.i;
-        r[dst].u.jsValue = returnValue;
+        int dst = callFrame[RegisterFile::ReturnValueRegister].i();
+        r[dst] = returnValue;
 
         NEXT_OPCODE;
@@ -2361 +2343 @@
         int argCount = (++vPC)->u.operand;
 
-        JSValue* constrVal = r[constr].u.jsValue;
+        JSValue* constrVal = r[constr].jsValue();
 
         ConstructData constructData;
@@ -2385 +2367 @@
             CodeBlock* newCodeBlock = &functionBodyNode->code(callDataScopeChain);
 
-            r[firstArg].u.jsValue = newObject; // "this" value
+            r[firstArg] = newObject; // "this" value
 
             Register* callFrame = r + firstArg - RegisterFile::CallFrameHeaderSize;
@@ -2407 +2389 @@
                 (*enabledProfilerReference)->willExecute(exec, constructor);
 
-            ArgList args(reinterpret_cast<JSValue**>(r) + firstArg + 1, argCount - 1);
+            ArgList args(r + firstArg + 1, argCount - 1);
             JSValue* returnValue = constructData.native.function(exec, constructor, args);
 
             VM_CHECK_EXCEPTION();
-            r[dst].u.jsValue = returnValue;
+            r[dst] = returnValue;
 
             if (*enabledProfilerReference)
@@ -2432 +2414 @@
         */
         int scope = (++vPC)->u.operand;
-        JSValue* v = r[scope].u.jsValue;
+        JSValue* v = r[scope].jsValue();
         JSObject* o = v->toObject(exec);
         VM_CHECK_EXCEPTION();
@@ -2462 +2444 @@
         int base = (++vPC)->u.operand;
 
-        r[dst].u.jsPropertyNameIterator = JSPropertyNameIterator::create(exec, r[base].u.jsValue);
+        r[dst] = JSPropertyNameIterator::create(exec, r[base].jsValue());
         ++vPC;
         NEXT_OPCODE;
@@ -2479 +2461 @@
         int target = (++vPC)->u.operand;
 
-        JSPropertyNameIterator* it = r[iter].u.jsPropertyNameIterator;
+        JSPropertyNameIterator* it = r[iter].jsPropertyNameIterator();
         if (JSValue* temp = it->next(exec)) {
             CHECK_FOR_TIMEOUT();
-            r[dst].u.jsValue = temp;
+            r[dst] = temp;
             vPC += target;
             NEXT_OPCODE;
@@ -2519 +2501 @@
         ASSERT(!exec->hadException());
         int ex = (++vPC)->u.operand;
-        r[ex].u.jsValue = exceptionValue;
+        r[ex] = exceptionValue;
         exceptionValue = 0;
 
@@ -2537 +2519 @@
 
         int ex = (++vPC)->u.operand;
-        exceptionValue = r[ex].u.jsValue;
+        exceptionValue = r[ex].jsValue();
         handlerVPC = throwException(exec, exceptionValue, vPC, codeBlock, k, scopeChain, r);
         if (!handlerVPC) {
@@ -2568 +2550 @@
         int message = (++vPC)->u.operand;
 
-        r[dst].u.jsValue = Error::create(exec, (ErrorType)type, k[message]->toString(exec), codeBlock->lineNumberForVPC(vPC), codeBlock->ownerNode->sourceId(), codeBlock->ownerNode->sourceURL());
+        r[dst] = Error::create(exec, (ErrorType)type, k[message]->toString(exec), codeBlock->lineNumberForVPC(vPC), codeBlock->ownerNode->sourceId(), codeBlock->ownerNode->sourceURL());
 
         ++vPC;
@@ -2585 +2567 @@
         }
         int result = (++vPC)->u.operand;
-        return r[result].u.jsValue;
+        return r[result].jsValue();
     }
     BEGIN_OPCODE(op_put_getter) {
@@ -2602 +2584 @@
         int function = (++vPC)->u.operand;
 
-        ASSERT(r[base].u.jsValue->isObject());
-        JSObject* baseObj = static_cast<JSObject*>(r[base].u.jsValue);
+        ASSERT(r[base].jsValue()->isObject());
+        JSObject* baseObj = static_cast<JSObject*>(r[base].jsValue());
         Identifier& ident = codeBlock->identifiers[property];
-        ASSERT(r[function].u.jsValue->isObject());
-        baseObj->defineGetter(exec, ident, static_cast<JSObject* >(r[function].u.jsValue));
+        ASSERT(r[function].jsValue()->isObject());
+        baseObj->defineGetter(exec, ident, static_cast<JSObject*>(r[function].jsValue()));
 
         ++vPC;
@@ -2626 +2608 @@
         int function = (++vPC)->u.operand;
 
-        ASSERT(r[base].u.jsValue->isObject());
-        JSObject* baseObj = static_cast<JSObject*>(r[base].u.jsValue);
+        ASSERT(r[base].jsValue()->isObject());
+        JSObject* baseObj = static_cast<JSObject*>(r[base].jsValue());
         Identifier& ident = codeBlock->identifiers[property];
-        ASSERT(r[function].u.jsValue->isObject());
-        baseObj->defineSetter(exec, ident, static_cast<JSObject* >(r[function].u.jsValue));
+        ASSERT(r[function].jsValue()->isObject());
+        baseObj->defineSetter(exec, ident, static_cast<JSObject*>(r[function].jsValue()));
 
         ++vPC;
@@ -2643 +2625 @@
         int retAddrDst = (++vPC)->u.operand;
         int target = (++vPC)->u.operand;
-        r[retAddrDst].u.vPC = vPC + 1;
+        r[retAddrDst] = vPC + 1;
 
         vPC += target;
@@ -2656 +2638 @@
         */
         int retAddrSrc = (++vPC)->u.operand;
-        vPC = r[retAddrSrc].u.vPC;
+        vPC = r[retAddrSrc].vPC();
         NEXT_OPCODE;
     }
@@ -2698 +2680 @@
         return jsNull();
 
-    JSActivation* activation = static_cast<JSActivation*>(callFrame[RegisterFile::OptionalCalleeActivation].u.jsValue);
+    JSActivation* activation = static_cast<JSActivation*>(callFrame[RegisterFile::OptionalCalleeActivation].jsValue());
     if (!activation) {
         CodeBlock* codeBlock = &function->m_body->generatedCode();
         activation = new (exec) JSActivation(function->m_body, callFrame + RegisterFile::CallFrameHeaderSize + codeBlock->numLocals);
-        callFrame[RegisterFile::OptionalCalleeActivation].u.jsValue = activation;
+        callFrame[RegisterFile::OptionalCalleeActivation] = activation;
     }
 
@@ -2714 +2696 @@
         return jsNull();
 
-    CodeBlock* callerCodeBlock = callFrame[RegisterFile::CallerCodeBlock].u.codeBlock;
+    CodeBlock* callerCodeBlock = callFrame[RegisterFile::CallerCodeBlock].codeBlock();
     if (!callerCodeBlock)
         return jsNull();
 
-    Register* callerCallFrame = callFrame[RegisterFile::CallerRegisters].u.r - callerCodeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
-    if (JSValue* caller = callerCallFrame[RegisterFile::Callee].u.jsValue)
+    Register* callerCallFrame = callFrame[RegisterFile::CallerRegisters].r() - callerCodeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
+    if (JSValue* caller = callerCallFrame[RegisterFile::Callee].jsValue())
         return caller;
 
@@ -2737 +2719 @@
         }
 
-        if (callFrame[RegisterFile::Callee].u.jsValue == function)
+        if (callFrame[RegisterFile::Callee].jsValue() == function)
             return callFrame;
 
-        CodeBlock* callerCodeBlock = callFrame[RegisterFile::CallerCodeBlock].u.codeBlock;
+        CodeBlock* callerCodeBlock = callFrame[RegisterFile::CallerCodeBlock].codeBlock();
         if (!callerCodeBlock) {
             callFrame = 0;
@@ -2746 +2728 @@
         }
         
-        callFrame = callFrame[RegisterFile::CallerRegisters].u.r - callerCodeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
+        callFrame = callFrame[RegisterFile::CallerRegisters].r() - callerCodeBlock->numLocals - RegisterFile::CallFrameHeaderSize;
     }
 }
@@ -2752 +2734 @@
 void Machine::getArgumentsData(Register* callFrame, JSFunction*& function, Register*& argv, int& argc)
 {
-    function = static_cast<JSFunction*>(callFrame[RegisterFile::Callee].u.jsValue);
+    function = static_cast<JSFunction*>(callFrame[RegisterFile::Callee].jsValue());
     ASSERT(function->inherits(&JSFunction::info));
 
-    argv = callFrame[RegisterFile::CallerRegisters].u.r + callFrame[RegisterFile::ArgumentStartRegister].u.i + 1; //  + 1 to skip "this"
-    argc = callFrame[RegisterFile::ArgumentCount].u.i - 1; // - 1 to skip "this"
+    argv = callFrame[RegisterFile::CallerRegisters].r() + callFrame[RegisterFile::ArgumentStartRegister].i() + 1; //  + 1 to skip "this"
+    argc = callFrame[RegisterFile::ArgumentCount].i() - 1; // - 1 to skip "this"
 }
 

trunk/JavaScriptCore/VM/Machine.h

@@ -124 +124 @@
         enum ExecutionFlag { Normal, InitializeAndReturn };
 
-        friend NEVER_INLINE JSValue* callEval(ExecState* exec, JSObject* thisObj, ScopeChainNode* scopeChain, RegisterFile*, Register* r, int argv, int argc, JSValue*& exceptionValue);
+        NEVER_INLINE JSValue* callEval(ExecState* exec, JSObject* thisObj, ScopeChainNode* scopeChain, RegisterFile*, Register* r, int argv, int argc, JSValue*& exceptionValue);
         JSValue* execute(EvalNode*, ExecState*, JSObject* thisObj, int registerOffset, ScopeChainNode*, JSValue** exception);
+
+        ALWAYS_INLINE void initializeCallFrame(Register* callFrame, CodeBlock*, Instruction*, ScopeChainNode*, Register* r, int returnValueRegister, int argv, int argc, int calledAsConstructor, JSValue* function);
 
         ALWAYS_INLINE void setScopeChain(ExecState* exec, ScopeChainNode*&, ScopeChainNode*);

trunk/JavaScriptCore/VM/Register.h

@@ -30 +30 @@
 #define Register_h
 
+#include "JSValue.h"
 #include <wtf/VectorTraits.h>
 
@@ -35 +36 @@
 
     class CodeBlock;
+    class ExecState;
     class JSFunction;
-    class JSObject;
     class JSPropertyNameIterator;
     class JSValue;
@@ -42 +43 @@
     struct Instruction;
 
-    struct Register {
+    class Register {
+    public:
+        Register();
+        Register(JSValue*);
+
+        JSValue* jsValue() const;
+
+        bool marked() const;
+        void mark();
+        
+        uint32_t toUInt32(ExecState*) const;
+        UString toString(ExecState*) const;
+
+    private:
+        friend class Machine;
+
+        // Only the Machine should use these functions.
+
+        Register(CodeBlock*);
+        Register(ScopeChainNode*);
+        Register(int);
+        Register(Register*);
+        Register(Instruction*);
+        Register(JSPropertyNameIterator*);
+
+        CodeBlock* codeBlock() const;
+        ScopeChainNode* scopeChain() const;
+        int i() const;
+        Register* r() const;
+        Instruction* vPC() const;
+        JSPropertyNameIterator* jsPropertyNameIterator() const;
+
         union {
+        private:
+            friend class Register;
+
             CodeBlock* codeBlock;
             Instruction* vPC;
             JSValue* jsValue;
-            JSObject* jsObject;
             ScopeChainNode* scopeChain;
             JSPropertyNameIterator* jsPropertyNameIterator;
@@ -53 +87 @@
             int i;
         } u;
+
+#ifndef NDEBUG
+        enum {
+            CodeBlockType = 0, 
+            InstructionType, 
+            JSValueType, 
+            ScopeChainNodeType, 
+            JSPropertyNameIteratorType, 
+            RegisterType, 
+            intType
+        } m_type;
+#endif
     };
 
+    ALWAYS_INLINE Register::Register()
+    {
+#ifndef NDEBUG
+        *this = 0;
+#endif
+    }
+
+    ALWAYS_INLINE Register::Register(JSValue* v)
+    {
+#ifndef NDEBUG
+        m_type = JSValueType;
+#endif
+        u.jsValue = v;
+    }
+    
+    ALWAYS_INLINE Register::Register(CodeBlock* codeBlock)
+    {
+#ifndef NDEBUG
+        m_type = CodeBlockType;
+#endif
+        u.codeBlock = codeBlock;
+    }
+
+    ALWAYS_INLINE Register::Register(Instruction* vPC)
+    {
+#ifndef NDEBUG
+        m_type = InstructionType;
+#endif
+        u.vPC = vPC;
+    }
+
+    ALWAYS_INLINE Register::Register(ScopeChainNode* scopeChain)
+    {
+#ifndef NDEBUG
+        m_type = ScopeChainNodeType;
+#endif
+        u.scopeChain = scopeChain;
+    }
+
+    ALWAYS_INLINE Register::Register(JSPropertyNameIterator* jsPropertyNameIterator)
+    {
+#ifndef NDEBUG
+        m_type = JSPropertyNameIteratorType;
+#endif
+        u.jsPropertyNameIterator = jsPropertyNameIterator;
+    }
+
+    ALWAYS_INLINE Register::Register(Register* r)
+    {
+#ifndef NDEBUG
+        m_type = RegisterType;
+#endif
+        u.r = r;
+    }
+
+    ALWAYS_INLINE Register::Register(int i)
+    {
+#ifndef NDEBUG
+        m_type = intType;
+#endif
+        u.i = i;
+    }
+
+    ALWAYS_INLINE JSValue* Register::jsValue() const
+    {
+        ASSERT(m_type == JSValueType || !i());
+        return u.jsValue;
+    }
+    
+    ALWAYS_INLINE CodeBlock* Register::codeBlock() const
+    {
+        ASSERT(m_type == CodeBlockType);
+        return u.codeBlock;
+    }
+    
+    ALWAYS_INLINE ScopeChainNode* Register::scopeChain() const
+    {
+        ASSERT(m_type == ScopeChainNodeType);
+        return u.scopeChain;
+    }
+    
+    ALWAYS_INLINE int Register::i() const
+    {
+        ASSERT(m_type == intType);
+        return u.i;
+    }
+    
+    ALWAYS_INLINE Register* Register::r() const
+    {
+        ASSERT(m_type == RegisterType);
+        return u.r;
+    }
+    
+    ALWAYS_INLINE Instruction* Register::vPC() const
+    {
+        ASSERT(m_type == InstructionType);
+        return u.vPC;
+    }
+    
+    ALWAYS_INLINE JSPropertyNameIterator* Register::jsPropertyNameIterator() const
+    {
+        ASSERT(m_type == JSPropertyNameIteratorType);
+        return u.jsPropertyNameIterator;
+    }
+    
+    ALWAYS_INLINE bool Register::marked() const
+    {
+        return jsValue()->marked();
+    }
+
+    ALWAYS_INLINE void Register::mark()
+    {
+        jsValue()->mark();
+    }
+    
+    ALWAYS_INLINE uint32_t Register::toUInt32(ExecState* exec) const
+    {
+        return jsValue()->toUInt32(exec);
+    }
+
+    ALWAYS_INLINE UString Register::toString(ExecState* exec) const
+    {
+        return jsValue()->toString(exec);
+    }
+
 } // namespace KJS
 

trunk/JavaScriptCore/kjs/ArgList.cpp

@@ -46 +46 @@
 
         iterator end2 = list->end();
-        for (iterator it2 = list->begin(); it2 != end2; ++it2) {
-            JSValue* v = *it2;
-            if (!v->marked())
-                v->mark();
-        }
+        for (iterator it2 = list->begin(); it2 != end2; ++it2)
+            if (!(*it2).marked())
+                (*it2).mark();
     }
 }

trunk/JavaScriptCore/kjs/ArgList.h

@@ -24 +24 @@
 
 #include "JSImmediate.h"
+#include "Register.h"
+
 #include <wtf/HashSet.h>
 #include <wtf/Noncopyable.h>
@@ -35 +37 @@
     private:
         static const unsigned inlineCapacity = 8;
-        typedef Vector<JSValue*, inlineCapacity> VectorType;
+        typedef Vector<Register, inlineCapacity> VectorType;
         typedef HashSet<ArgList*> ListSet;
 
@@ -55 +57 @@
 
         // Constructor for a read-only list whose data has already been allocated elsewhere.
-        ArgList(JSValue** buffer, size_t size)
+        ArgList(Register* buffer, size_t size)
             : m_buffer(buffer)
             , m_size(size)
@@ -77 +79 @@
         {
             if (i < m_size)
-                return m_buffer[i];
+                return m_buffer[i].jsValue();
             return jsUndefined();
         }
@@ -118 +120 @@
         void slowAppend(JSValue*);
         
-        JSValue** m_buffer;
+        Register* m_buffer;
         size_t m_size;
 

trunk/JavaScriptCore/kjs/Arguments.cpp

@@ -49 +49 @@
         Identifier name = Identifier::from(exec, i);
         if (!m_indexToNameMap.isMapped(name))
-            putDirect(name, *it, DontEnum);
+            putDirect(name, (*it).jsValue(), DontEnum);
     }
 }

trunk/JavaScriptCore/kjs/ArrayPrototype.cpp

@@ -275 +275 @@
         if (it == end)
             break;
-        curArg = *it;
+        curArg = (*it).jsValue();
         ++it;
     }

trunk/JavaScriptCore/kjs/DebuggerCallFrame.cpp

@@ -47 +47 @@
         return 0;
 
-    JSFunction* function = static_cast<JSFunction*>(callFrame()[RegisterFile::Callee].u.jsValue);
+    JSFunction* function = static_cast<JSFunction*>(callFrame()[RegisterFile::Callee].jsValue());
     if (!function)
         return 0;
@@ -55 +55 @@
 DebuggerCallFrame::Type DebuggerCallFrame::type() const
 {
-    if (callFrame()[RegisterFile::Callee].u.jsObject)
+    if (callFrame()[RegisterFile::Callee].jsValue())
         return FunctionType;
 
@@ -66 +66 @@
         return 0;
 
-    return static_cast<JSObject*>(m_registers[m_codeBlock->thisRegister].u.jsValue);
+    return static_cast<JSObject*>(m_registers[m_codeBlock->thisRegister].jsValue());
 }
 

trunk/JavaScriptCore/kjs/IndexToNameMap.cpp

@@ -45 +45 @@
     , m_map(new Identifier[args.size()])
 {
-    unsigned i = 0;
-    ArgList::const_iterator end = args.end();
-    for (ArgList::const_iterator it = args.begin(); it != end; ++i, ++it)
+    size_t size = args.size();
+    for (size_t i = 0; i < size; ++i)
         m_map[i] = func->getParameterName(i); // null if there is no corresponding parameter
 }

trunk/JavaScriptCore/kjs/JSActivation.cpp

@@ -164 +164 @@
     exec->machine()->getArgumentsData(callFrame, function, argv, argc);
 
-    ArgList args(reinterpret_cast<JSValue**>(argv), argc);
+    ArgList args(argv, argc);
     return new (exec) Arguments(exec, function, args, this);
 }

trunk/JavaScriptCore/kjs/JSArray.cpp

@@ -104 +104 @@
     ArgList::const_iterator end = list.end();
     for (ArgList::const_iterator it = list.begin(); it != end; ++it, ++i)
-        storage->m_vector[i] = *it;
+        storage->m_vector[i] = (*it).jsValue();
 
     m_storage = storage;

trunk/JavaScriptCore/kjs/JSGlobalObject.h

@@ -269 +269 @@
             SymbolTableEntry newEntry(index, global.attributes);
             symbolTable().add(global.identifier.ustring().rep(), newEntry);
-            valueAt(index) = global.value;
+            registerAt(index) = global.value;
         }
     }

trunk/JavaScriptCore/kjs/JSString.h

@@ -26 +26 @@
 
 #include "CommonIdentifiers.h"
+#include "ExecState.h"
 #include "JSCell.h"
 #include "PropertySlot.h"

trunk/JavaScriptCore/kjs/JSValue.h

@@ -26 +26 @@
 #include "CallData.h"
 #include "ConstructData.h"
-#include "ExecState.h"
 #include "JSImmediate.h"
 #include "ustring.h"
@@ -112 +111 @@
         // These are identical logic to above, and faster than jsNumber(number)->toInt32(exec)
         static int32_t toInt32(double);
-        static int32_t toUInt32(double);
+        static uint32_t toUInt32(double);
 
         // Floating point conversions.
@@ -219 +218 @@
     }
 
-    inline int32_t JSValue::toUInt32(double val)
+    inline uint32_t JSValue::toUInt32(double val)
     {
         if (!(val >= 0.0 && val < 4294967296.0)) {

trunk/JavaScriptCore/kjs/JSVariableObject.cpp

@@ -72 +72 @@
     
     Register* end = d->registerArray.get() + d->registerArraySize;
-    for (Register* it = d->registerArray.get(); it != end; ++it) {
-        JSValue* v = (*it).u.jsValue;
-        if (!v->marked())
-            v->mark();
-    }
+    for (Register* it = d->registerArray.get(); it != end; ++it)
+        if (!(*it).marked())
+            (*it).mark();
 }
 

trunk/JavaScriptCore/kjs/JSVariableObject.h

@@ -56 +56 @@
         virtual bool getPropertyAttributes(ExecState*, const Identifier& propertyName, unsigned& attributes) const;
 
-        JSValue*& valueAt(int index) const { return d->registers[index].u.jsValue; }
+        Register& registerAt(int index) const { return d->registers[index]; }
 
     protected:
@@ -107 +107 @@
         SymbolTableEntry entry = symbolTable().inlineGet(propertyName.ustring().rep());
         if (!entry.isNull()) {
-            slot.setValueSlot(&valueAt(entry.getIndex()));
+            slot.setRegisterSlot(&registerAt(entry.getIndex()));
             return true;
         }
@@ -117 +117 @@
         SymbolTableEntry entry = symbolTable().inlineGet(propertyName.ustring().rep());
         if (!entry.isNull()) {
-            slot.setValueSlot(&valueAt(entry.getIndex()));
+            slot.setRegisterSlot(&registerAt(entry.getIndex()));
             slotIsWriteable = !entry.isReadOnly();
             return true;
@@ -131 +131 @@
         if (entry.isReadOnly())
             return true;
-        valueAt(entry.getIndex()) = value;
+        registerAt(entry.getIndex()) = value;
         return true;
     }
@@ -143 +143 @@
         ASSERT(!entry.isNull());
         entry.setAttributes(attributes);
-        valueAt(entry.getIndex()) = value;
+        registerAt(entry.getIndex()) = value;
         return true;
     }

trunk/JavaScriptCore/kjs/PropertySlot.h

@@ -22 +22 @@
 #define PropertySlot_h
 
+#include "Register.h"
 #include "JSValue.h"
 #include "identifier.h"
@@ -33 +34 @@
 
 #define KJS_VALUE_SLOT_MARKER 0
-#define KJS_NUMERIC_PROPERTY_NAME_SLOT_MARKER reinterpret_cast<GetValueFunc>(1)
+#define KJS_REGISTER_SLOT_MARKER reinterpret_cast<GetValueFunc>(1)
+#define KJS_NUMERIC_PROPERTY_NAME_SLOT_MARKER reinterpret_cast<GetValueFunc>(2)
 
     class PropertySlot {
@@ -54 +56 @@
             if (m_getValue == KJS_VALUE_SLOT_MARKER)
                 return *m_data.valueSlot;
+            if (m_getValue == KJS_REGISTER_SLOT_MARKER)
+                return (*m_data.registerSlot).jsValue();
             ASSERT(m_getValue != KJS_NUMERIC_PROPERTY_NAME_SLOT_MARKER);
             return m_getValue(exec, propertyName, *this);
@@ -64 +68 @@
             if (m_getValue == KJS_NUMERIC_PROPERTY_NAME_SLOT_MARKER)
                 return m_data.numericFunc(exec, propertyName, *this);
+            if (m_getValue == KJS_REGISTER_SLOT_MARKER)
+                return (*m_data.registerSlot).jsValue();
             return m_getValue(exec, Identifier::from(exec, propertyName), *this);
         }
@@ -69 +75 @@
         void putValue(JSValue* value)
         { 
-            ASSERT(m_getValue == KJS_VALUE_SLOT_MARKER);
-            *m_data.valueSlot = value;
+            if (m_getValue == KJS_VALUE_SLOT_MARKER) {
+                *m_data.valueSlot = value;
+                return;
+            }
+            ASSERT(m_getValue == KJS_REGISTER_SLOT_MARKER);
+            *m_data.registerSlot = value;
         }
-        
+
         void setValueSlot(JSValue** valueSlot) 
         {
@@ -79 +89 @@
             clearBase();
             m_data.valueSlot = valueSlot;
+        }
+        
+        void setRegisterSlot(Register* registerSlot)
+        {
+            ASSERT(registerSlot);
+            m_getValue = KJS_REGISTER_SLOT_MARKER;
+            clearBase();
+            m_data.registerSlot = registerSlot;
         }
 
@@ -163 +181 @@
             JSObject* getterFunc;
             JSValue** valueSlot;
+            Register* registerSlot;
             const HashEntry* staticEntry;
             unsigned index;

trunk/JavaScriptCore/kjs/StringConstructor.cpp

@@ -37 +37 @@
         ArgList::const_iterator end = args.end();
         for (ArgList::const_iterator it = args.begin(); it != end; ++it)
-            *p++ = static_cast<UChar>((*it)->toUInt32(exec));
+            *p++ = static_cast<UChar>((*it).toUInt32(exec));
         s = UString::adopt(buf, args.size());
     } else

trunk/JavaScriptCore/kjs/StringPrototype.cpp

@@ -351 +351 @@
     ArgList::const_iterator end = args.end();
     for (ArgList::const_iterator it = args.begin(); it != end; ++it)
-        s += (*it)->toString(exec);
+        s += (*it).toString(exec);
     return jsString(exec, s);
 }

trunk/WebCore/ChangeLog

@@ +1 @@
+2008-07-16  Geoffrey Garen  <ggaren@apple.com>
+
+        Reviewed by Oliver Hunt.
+
+        Support for JavaScriptCore's first step toward putting doubles in
+        registers: Treat ArgList iterators as Register*'s, not JSValue*'s.
+
+        * bindings/js/ScheduledAction.cpp:
+        (WebCore::ScheduledAction::ScheduledAction):
+
 2008-07-15  Maxime Britto  <britto@apple.com>
 

trunk/WebCore/bindings/js/ScheduledAction.cpp

@@ -43 +43 @@
     ArgList::const_iterator end = args.end();
     for (ArgList::const_iterator it = args.begin(); it != end; ++it)
-        m_args.append(*it);
+        m_args.append((*it).jsValue());
 }