<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[38467] trunk/JavaScriptCore</title>
</head>
<body>

<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt;  }
#msg dl a { font-weight: bold}
#msg dl a:link    { color:#fc3; }
#msg dl a:active  { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff  {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/38467">38467</a></dd>
<dt>Author</dt> <dd>ggaren@apple.com</dd>
<dt>Date</dt> <dd>2008-11-16 19:02:43 -0800 (Sun, 16 Nov 2008)</dd>
</dl>

<h3>Log Message</h3>
<pre>2008-11-16  Geoffrey Garen  &lt;ggaren@apple.com&gt;

        Reviewed by Sam Weinig.
        
        Renamed OBJECT_OFFSET =&gt; FIELD_OFFSET

        Nixed use of OBJECT_OFFSET outside of CTI.cpp by making CTI a friend in
        more places.

        * VM/CTI.cpp:
        (JSC::CTI::compileOpCallInitializeCallFrame):
        (JSC::CTI::compileOpCall):
        (JSC::CTI::emitSlowScriptCheck):
        (JSC::CTI::putDoubleResultToJSNumberCellOrJSImmediate):
        (JSC::CTI::compileBinaryArithOp):
        (JSC::CTI::privateCompileMainPass):
        (JSC::CTI::privateCompileSlowCases):
        (JSC::CTI::privateCompile):
        (JSC::CTI::privateCompileGetByIdSelf):
        (JSC::CTI::privateCompileGetByIdProto):
        (JSC::CTI::privateCompileGetByIdChain):
        (JSC::CTI::privateCompilePutByIdReplace):
        (JSC::CTI::privateCompilePutByIdTransition):
        (JSC::CTI::privateCompileCTIMachineTrampolines):
        (JSC::CTI::privateCompilePatchGetArrayLength):
        (JSC::CTI::emitGetVariableObjectRegister):
        (JSC::CTI::emitPutVariableObjectRegister):
        * runtime/JSValue.h:
        * runtime/JSVariableObject.h:</pre>

<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkJavaScriptCoreChangeLog">trunk/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkJavaScriptCoreVMCTIcpp">trunk/JavaScriptCore/VM/CTI.cpp</a></li>
<li><a href="#trunkJavaScriptCoreruntimeJSValueh">trunk/JavaScriptCore/runtime/JSValue.h</a></li>
<li><a href="#trunkJavaScriptCoreruntimeJSVariableObjecth">trunk/JavaScriptCore/runtime/JSVariableObject.h</a></li>
</ul>

</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/ChangeLog (38466 => 38467)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/ChangeLog        2008-11-17 02:40:28 UTC (rev 38466)
+++ trunk/JavaScriptCore/ChangeLog        2008-11-17 03:02:43 UTC (rev 38467)
</span><span class="lines">@@ -2,6 +2,36 @@
</span><span class="cx"> 
</span><span class="cx">         Reviewed by Sam Weinig.
</span><span class="cx">         
</span><ins>+        Renamed OBJECT_OFFSET =&gt; FIELD_OFFSET
+
+        Nixed use of OBJECT_OFFSET outside of CTI.cpp by making CTI a friend in
+        more places.
+
+        * VM/CTI.cpp:
+        (JSC::CTI::compileOpCallInitializeCallFrame):
+        (JSC::CTI::compileOpCall):
+        (JSC::CTI::emitSlowScriptCheck):
+        (JSC::CTI::putDoubleResultToJSNumberCellOrJSImmediate):
+        (JSC::CTI::compileBinaryArithOp):
+        (JSC::CTI::privateCompileMainPass):
+        (JSC::CTI::privateCompileSlowCases):
+        (JSC::CTI::privateCompile):
+        (JSC::CTI::privateCompileGetByIdSelf):
+        (JSC::CTI::privateCompileGetByIdProto):
+        (JSC::CTI::privateCompileGetByIdChain):
+        (JSC::CTI::privateCompilePutByIdReplace):
+        (JSC::CTI::privateCompilePutByIdTransition):
+        (JSC::CTI::privateCompileCTIMachineTrampolines):
+        (JSC::CTI::privateCompilePatchGetArrayLength):
+        (JSC::CTI::emitGetVariableObjectRegister):
+        (JSC::CTI::emitPutVariableObjectRegister):
+        * runtime/JSValue.h:
+        * runtime/JSVariableObject.h:
+
+2008-11-16  Geoffrey Garen  &lt;ggaren@apple.com&gt;
+
+        Reviewed by Sam Weinig.
+        
</ins><span class="cx">         Renames:
</span><span class="cx">         
</span><span class="cx">         X86Assembler::copy =&gt; X86Assembler::executableCopy
</span></span></pre></div>
<a id="trunkJavaScriptCoreVMCTIcpp"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/VM/CTI.cpp (38466 => 38467)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/VM/CTI.cpp        2008-11-17 02:40:28 UTC (rev 38466)
+++ trunk/JavaScriptCore/VM/CTI.cpp        2008-11-17 03:02:43 UTC (rev 38467)
</span><span class="lines">@@ -42,6 +42,11 @@
</span><span class="cx"> 
</span><span class="cx"> #define __ m_assembler. 
</span><span class="cx"> 
</span><ins>+// FIELD_OFFSET: Like the C++ offsetof macro, but you can use it with classes.
+// The magic number 0x4000 is insignificant. We use it to avoid using NULL, since
+// NULL can cause compiler problems, especially in cases of multiple inheritance.
+#define FIELD_OFFSET(class, field) (reinterpret_cast&lt;ptrdiff_t&gt;(&amp;(reinterpret_cast&lt;class*&gt;(0x4000)-&gt;field)) - 0x4000)
+
</ins><span class="cx"> using namespace std;
</span><span class="cx"> 
</span><span class="cx"> namespace JSC {
</span><span class="lines">@@ -657,7 +662,7 @@
</span><span class="cx"> {
</span><span class="cx">     __ movl_rm(X86::edx, RegisterFile::ArgumentCount * static_cast&lt;int&gt;(sizeof(Register)), X86::edi);
</span><span class="cx"> 
</span><del>-    __ movl_mr(OBJECT_OFFSET(JSFunction, m_scopeChain) + OBJECT_OFFSET(ScopeChain, m_node), X86::ecx, X86::edx); // newScopeChain
</del><ins>+    __ movl_mr(FIELD_OFFSET(JSFunction, m_scopeChain) + FIELD_OFFSET(ScopeChain, m_node), X86::ecx, X86::edx); // newScopeChain
</ins><span class="cx"> 
</span><span class="cx">     __ movl_i32m(asInteger(noValue()), RegisterFile::OptionalCalleeArguments * static_cast&lt;int&gt;(sizeof(Register)), X86::edi);
</span><span class="cx">     __ movl_rm(X86::ecx, RegisterFile::Callee * static_cast&lt;int&gt;(sizeof(Register)), X86::edi);
</span><span class="lines">@@ -749,7 +754,7 @@
</span><span class="cx">     // Note that this omits to set up RegisterFile::CodeBlock, which is set in the callee
</span><span class="cx">     __ movl_i32m(asInteger(noValue()), (registerOffset + RegisterFile::OptionalCalleeArguments) * static_cast&lt;int&gt;(sizeof(Register)), X86::edi);
</span><span class="cx">     __ movl_rm(X86::ecx, (registerOffset + RegisterFile::Callee) * static_cast&lt;int&gt;(sizeof(Register)), X86::edi);
</span><del>-    __ movl_mr(OBJECT_OFFSET(JSFunction, m_scopeChain) + OBJECT_OFFSET(ScopeChain, m_node), X86::ecx, X86::edx); // newScopeChain
</del><ins>+    __ movl_mr(FIELD_OFFSET(JSFunction, m_scopeChain) + FIELD_OFFSET(ScopeChain, m_node), X86::ecx, X86::edx); // newScopeChain
</ins><span class="cx">     __ movl_i32m(argCount, (registerOffset + RegisterFile::ArgumentCount) * static_cast&lt;int&gt;(sizeof(Register)), X86::edi);
</span><span class="cx">     __ movl_rm(X86::edi, (registerOffset + RegisterFile::CallerFrame) * static_cast&lt;int&gt;(sizeof(Register)), X86::edi);
</span><span class="cx">     __ movl_rm(X86::edx, (registerOffset + RegisterFile::ScopeChain) * static_cast&lt;int&gt;(sizeof(Register)), X86::edi);
</span><span class="lines">@@ -831,8 +836,8 @@
</span><span class="cx">     emitCTICall(vPC, bytecodeIndex, Interpreter::cti_timeout_check);
</span><span class="cx"> 
</span><span class="cx">     emitGetCTIParam(CTI_ARGS_globalData, X86::ecx);
</span><del>-    __ movl_mr(OBJECT_OFFSET(JSGlobalData, interpreter), X86::ecx, X86::ecx);
-    __ movl_mr(OBJECT_OFFSET(Interpreter, m_ticksUntilNextTimeoutCheck), X86::ecx, X86::esi);
</del><ins>+    __ movl_mr(FIELD_OFFSET(JSGlobalData, interpreter), X86::ecx, X86::ecx);
+    __ movl_mr(FIELD_OFFSET(Interpreter, m_ticksUntilNextTimeoutCheck), X86::ecx, X86::esi);
</ins><span class="cx">     __ link(skipTimeout, __ label());
</span><span class="cx"> 
</span><span class="cx">     killLastResultRegister();
</span><span class="lines">@@ -860,7 +865,7 @@
</span><span class="cx">     X86Assembler::JmpDst resultLookedLikeImmButActuallyIsnt = __ label();
</span><span class="cx">     
</span><span class="cx">     // Store the result to the JSNumberCell and jump.
</span><del>-    __ movsd_rm(xmmSource, OBJECT_OFFSET(JSNumberCell, m_value), jsNumberCell);
</del><ins>+    __ movsd_rm(xmmSource, FIELD_OFFSET(JSNumberCell, m_value), jsNumberCell);
</ins><span class="cx">     if (jsNumberCell != X86::eax)
</span><span class="cx">         __ movl_rr(jsNumberCell, X86::eax);
</span><span class="cx">     emitPutVirtualRegister(dst);
</span><span class="lines">@@ -898,7 +903,7 @@
</span><span class="cx">         X86Assembler::JmpSrc op2imm = __ emitUnlinkedJne();
</span><span class="cx">         if (!types.second().definitelyIsNumber()) {
</span><span class="cx">             emitJumpSlowCaseIfNotJSCell(X86::edx, i, src2);
</span><del>-            __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(numberStructure), OBJECT_OFFSET(JSCell, m_structure), X86::edx);
</del><ins>+            __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::edx);
</ins><span class="cx">             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="lines">@@ -908,12 +913,12 @@
</span><span class="cx">         X86Assembler::JmpSrc op1imm = __ emitUnlinkedJne();
</span><span class="cx">         if (!types.first().definitelyIsNumber()) {
</span><span class="cx">             emitJumpSlowCaseIfNotJSCell(X86::eax, i, src1);
</span><del>-            __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(numberStructure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
</del><ins>+            __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</ins><span class="cx">             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         // (1a) if we get here, src1 is also a number cell
</span><del>-        __ movsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
</del><ins>+        __ movsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
</ins><span class="cx">         X86Assembler::JmpSrc loadedDouble = __ emitUnlinkedJmp();
</span><span class="cx">         // (1b) if we get here, src1 is an immediate
</span><span class="cx">         __ link(op1imm, __ label());
</span><span class="lines">@@ -922,12 +927,12 @@
</span><span class="cx">         // (1c) 
</span><span class="cx">         __ link(loadedDouble, __ label());
</span><span class="cx">         if (opcodeID == op_add)
</span><del>-            __ addsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm0);
</del><ins>+            __ addsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm0);
</ins><span class="cx">         else if (opcodeID == op_sub)
</span><del>-            __ subsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm0);
</del><ins>+            __ subsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm0);
</ins><span class="cx">         else {
</span><span class="cx">             ASSERT(opcodeID == op_mul);
</span><del>-            __ mulsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm0);
</del><ins>+            __ mulsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm0);
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         putDoubleResultToJSNumberCellOrJSImmediate(X86::xmm0, X86::edx, dst, &amp;wasJSNumberCell2, X86::xmm1, X86::ecx, X86::eax);
</span><span class="lines">@@ -945,7 +950,7 @@
</span><span class="cx">         X86Assembler::JmpSrc op1imm = __ emitUnlinkedJne();
</span><span class="cx">         if (!types.first().definitelyIsNumber()) {
</span><span class="cx">             emitJumpSlowCaseIfNotJSCell(X86::eax, i, src1);
</span><del>-            __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(numberStructure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
</del><ins>+            __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</ins><span class="cx">             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="lines">@@ -955,12 +960,12 @@
</span><span class="cx">         X86Assembler::JmpSrc op2imm = __ emitUnlinkedJne();
</span><span class="cx">         if (!types.second().definitelyIsNumber()) {
</span><span class="cx">             emitJumpSlowCaseIfNotJSCell(X86::edx, i, src2);
</span><del>-            __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(numberStructure), OBJECT_OFFSET(JSCell, m_structure), X86::edx);
</del><ins>+            __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::edx);
</ins><span class="cx">             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         // (1a) if we get here, src2 is also a number cell
</span><del>-        __ movsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm1);
</del><ins>+        __ movsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm1);
</ins><span class="cx">         X86Assembler::JmpSrc loadedDouble = __ emitUnlinkedJmp();
</span><span class="cx">         // (1b) if we get here, src2 is an immediate
</span><span class="cx">         __ link(op2imm, __ label());
</span><span class="lines">@@ -968,7 +973,7 @@
</span><span class="cx">         __ cvtsi2sd_rr(X86::edx, X86::xmm1);
</span><span class="cx">         // (1c) 
</span><span class="cx">         __ link(loadedDouble, __ label());
</span><del>-        __ movsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
</del><ins>+        __ movsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
</ins><span class="cx">         if (opcodeID == op_add)
</span><span class="cx">             __ addsd_rr(X86::xmm1, X86::xmm0);
</span><span class="cx">         else if (opcodeID == op_sub)
</span><span class="lines">@@ -977,7 +982,7 @@
</span><span class="cx">             ASSERT(opcodeID == op_mul);
</span><span class="cx">             __ mulsd_rr(X86::xmm1, X86::xmm0);
</span><span class="cx">         }
</span><del>-        __ movsd_rm(X86::xmm0, OBJECT_OFFSET(JSNumberCell, m_value), X86::eax);
</del><ins>+        __ movsd_rm(X86::xmm0, FIELD_OFFSET(JSNumberCell, m_value), X86::eax);
</ins><span class="cx">         emitPutVirtualRegister(dst);
</span><span class="cx"> 
</span><span class="cx">         putDoubleResultToJSNumberCellOrJSImmediate(X86::xmm0, X86::eax, dst, &amp;wasJSNumberCell1, X86::xmm1, X86::ecx, X86::edx);
</span><span class="lines">@@ -1235,12 +1240,12 @@
</span><span class="cx">             ++propertyAccessInstructionIndex;
</span><span class="cx"> 
</span><span class="cx">             // It is important that the following instruction plants a 32bit immediate, in order that it can be patched over.
</span><del>-            __ cmpl_i32m(repatchGetByIdDefaultStructure, OBJECT_OFFSET(JSCell, m_structure), X86::eax);
</del><ins>+            __ cmpl_i32m(repatchGetByIdDefaultStructure, FIELD_OFFSET(JSCell, m_structure), X86::eax);
</ins><span class="cx">             ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetPutByIdStructure);
</span><span class="cx">             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</span><span class="cx"> 
</span><span class="cx">             // Plant a load from a bogus ofset in the object's property map; we will patch this later, if it is to be used.
</span><del>-            __ movl_mr(OBJECT_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
</del><ins>+            __ movl_mr(FIELD_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
</ins><span class="cx">             __ movl_rm(X86::edx, repatchGetByIdDefaultOffset, X86::eax);
</span><span class="cx">             ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetPutByIdPropertyMapOffset);
</span><span class="cx"> 
</span><span class="lines">@@ -1264,12 +1269,12 @@
</span><span class="cx">             m_propertyAccessCompilationInfo[propertyAccessInstructionIndex].hotPathBegin = hotPathBegin;
</span><span class="cx">             ++propertyAccessInstructionIndex;
</span><span class="cx"> 
</span><del>-            __ cmpl_i32m(repatchGetByIdDefaultStructure, OBJECT_OFFSET(JSCell, m_structure), X86::eax);
</del><ins>+            __ cmpl_i32m(repatchGetByIdDefaultStructure, FIELD_OFFSET(JSCell, m_structure), X86::eax);
</ins><span class="cx">             ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetGetByIdStructure);
</span><span class="cx">             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</span><span class="cx">             ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetGetByIdBranchToSlowCase);
</span><span class="cx"> 
</span><del>-            __ movl_mr(OBJECT_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
</del><ins>+            __ movl_mr(FIELD_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
</ins><span class="cx">             __ movl_mr(repatchGetByIdDefaultOffset, X86::eax, X86::eax);
</span><span class="cx">             ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetGetByIdPropertyMapOffset);
</span><span class="cx">             emitPutVirtualRegister(instruction[i + 1].u.operand);
</span><span class="lines">@@ -1293,18 +1298,18 @@
</span><span class="cx">             // we check that the sum of the three type codes from Structures is exactly 3 * ObjectType,
</span><span class="cx">             // this works because NumberType and StringType are smaller
</span><span class="cx">             __ movl_i32r(3 * ObjectType, X86::ecx);
</span><del>-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::eax);
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::edx, X86::edx);
-            __ subl_mr(OBJECT_OFFSET(Structure, m_typeInfo.m_type), X86::eax, X86::ecx);
-            __ subl_mr(OBJECT_OFFSET(Structure, m_typeInfo.m_type), X86::edx, X86::ecx);
</del><ins>+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::eax);
+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::edx, X86::edx);
+            __ subl_mr(FIELD_OFFSET(Structure, m_typeInfo.m_type), X86::eax, X86::ecx);
+            __ subl_mr(FIELD_OFFSET(Structure, m_typeInfo.m_type), X86::edx, X86::ecx);
</ins><span class="cx">             emitGetVirtualRegister(instruction[i + 3].u.operand, X86::edx, i); // reload baseVal
</span><del>-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::edx, X86::edx);
-            __ cmpl_rm(X86::ecx, OBJECT_OFFSET(Structure, m_typeInfo.m_type), X86::edx);
</del><ins>+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::edx, X86::edx);
+            __ cmpl_rm(X86::ecx, FIELD_OFFSET(Structure, m_typeInfo.m_type), X86::edx);
</ins><span class="cx"> 
</span><span class="cx">             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</span><span class="cx"> 
</span><span class="cx">             // check that baseVal's flags include ImplementsHasInstance but not OverridesHasInstance
</span><del>-            __ movl_mr(OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::edx, X86::ecx);
</del><ins>+            __ movl_mr(FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::edx, X86::ecx);
</ins><span class="cx">             __ andl_i32r(ImplementsHasInstance | OverridesHasInstance, X86::ecx);
</span><span class="cx">             __ cmpl_i32r(ImplementsHasInstance, X86::ecx);
</span><span class="cx"> 
</span><span class="lines">@@ -1319,8 +1324,8 @@
</span><span class="cx">             X86Assembler::JmpDst loop = __ label();
</span><span class="cx"> 
</span><span class="cx">             // load value's prototype
</span><del>-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::ecx, X86::ecx);
-            __ movl_mr(OBJECT_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
</del><ins>+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::ecx, X86::ecx);
+            __ movl_mr(FIELD_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
</ins><span class="cx">             
</span><span class="cx">             __ cmpl_rr(X86::ecx, X86::edx);
</span><span class="cx">             X86Assembler::JmpSrc exit = __ emitUnlinkedJe();
</span><span class="lines">@@ -1414,9 +1419,9 @@
</span><span class="cx"> 
</span><span class="cx">             emitGetVirtualRegister(RegisterFile::ScopeChain, X86::eax, i);
</span><span class="cx">             while (skip--)
</span><del>-                __ movl_mr(OBJECT_OFFSET(ScopeChainNode, next), X86::eax, X86::eax);
</del><ins>+                __ movl_mr(FIELD_OFFSET(ScopeChainNode, next), X86::eax, X86::eax);
</ins><span class="cx"> 
</span><del>-            __ movl_mr(OBJECT_OFFSET(ScopeChainNode, object), X86::eax, X86::eax);
</del><ins>+            __ movl_mr(FIELD_OFFSET(ScopeChainNode, object), X86::eax, X86::eax);
</ins><span class="cx">             emitGetVariableObjectRegister(X86::eax, instruction[i + 2].u.operand, X86::eax);
</span><span class="cx">             emitPutVirtualRegister(instruction[i + 1].u.operand);
</span><span class="cx">             i += 4;
</span><span class="lines">@@ -1428,9 +1433,9 @@
</span><span class="cx">             emitGetVirtualRegister(RegisterFile::ScopeChain, X86::edx, i);
</span><span class="cx">             emitGetVirtualRegister(instruction[i + 3].u.operand, X86::eax, i);
</span><span class="cx">             while (skip--)
</span><del>-                __ movl_mr(OBJECT_OFFSET(ScopeChainNode, next), X86::edx, X86::edx);
</del><ins>+                __ movl_mr(FIELD_OFFSET(ScopeChainNode, next), X86::edx, X86::edx);
</ins><span class="cx"> 
</span><del>-            __ movl_mr(OBJECT_OFFSET(ScopeChainNode, object), X86::edx, X86::edx);
</del><ins>+            __ movl_mr(FIELD_OFFSET(ScopeChainNode, object), X86::edx, X86::edx);
</ins><span class="cx">             emitPutVariableObjectRegister(X86::eax, X86::edx, instruction[i + 1].u.operand);
</span><span class="cx">             i += 4;
</span><span class="cx">             break;
</span><span class="lines">@@ -1489,8 +1494,8 @@
</span><span class="cx"> 
</span><span class="cx">             __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><span class="cx">             X86Assembler::JmpSrc isImmediate = __ emitUnlinkedJne();
</span><del>-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
-            __ cmpl_i32m(ObjectType, OBJECT_OFFSET(Structure, m_typeInfo) + OBJECT_OFFSET(TypeInfo, m_type), X86::ecx);
</del><ins>+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ cmpl_i32m(ObjectType, FIELD_OFFSET(Structure, m_typeInfo) + FIELD_OFFSET(TypeInfo, m_type), X86::ecx);
</ins><span class="cx">             X86Assembler::JmpSrc isObject = __ emitUnlinkedJe();
</span><span class="cx"> 
</span><span class="cx">             __ link(isImmediate, __ label());
</span><span class="lines">@@ -1511,12 +1516,12 @@
</span><span class="cx">             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</span><span class="cx"> 
</span><span class="cx">             // This is an array; get the m_storage pointer into ecx, then check if the index is below the fast cutoff
</span><del>-            __ movl_mr(OBJECT_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
-            __ cmpl_rm(X86::edx, OBJECT_OFFSET(JSArray, m_fastAccessCutoff), X86::eax);
</del><ins>+            __ movl_mr(FIELD_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
+            __ cmpl_rm(X86::edx, FIELD_OFFSET(JSArray, m_fastAccessCutoff), X86::eax);
</ins><span class="cx">             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJbe(), i));
</span><span class="cx"> 
</span><span class="cx">             // Get the value from the vector
</span><del>-            __ movl_mr(OBJECT_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*), X86::eax);
</del><ins>+            __ movl_mr(FIELD_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*), X86::eax);
</ins><span class="cx">             emitPutVirtualRegister(instruction[i + 1].u.operand);
</span><span class="cx">             i += 4;
</span><span class="cx">             break;
</span><span class="lines">@@ -1545,22 +1550,22 @@
</span><span class="cx">             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</span><span class="cx"> 
</span><span class="cx">             // This is an array; get the m_storage pointer into ecx, then check if the index is below the fast cutoff
</span><del>-            __ movl_mr(OBJECT_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
-            __ cmpl_rm(X86::edx, OBJECT_OFFSET(JSArray, m_fastAccessCutoff), X86::eax);
</del><ins>+            __ movl_mr(FIELD_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
+            __ cmpl_rm(X86::edx, FIELD_OFFSET(JSArray, m_fastAccessCutoff), X86::eax);
</ins><span class="cx">             X86Assembler::JmpSrc inFastVector = __ emitUnlinkedJa();
</span><span class="cx">             // No; oh well, check if the access if within the vector - if so, we may still be okay.
</span><del>-            __ cmpl_rm(X86::edx, OBJECT_OFFSET(ArrayStorage, m_vectorLength), X86::ecx);
</del><ins>+            __ cmpl_rm(X86::edx, FIELD_OFFSET(ArrayStorage, m_vectorLength), X86::ecx);
</ins><span class="cx">             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJbe(), i));
</span><span class="cx"> 
</span><span class="cx">             // This is a write to the slow part of the vector; first, we have to check if this would be the first write to this location.
</span><span class="cx">             // FIXME: should be able to handle initial write to array; increment the the number of items in the array, and potentially update fast access cutoff. 
</span><del>-            __ cmpl_i8m(0, OBJECT_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*));
</del><ins>+            __ cmpl_i8m(0, FIELD_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*));
</ins><span class="cx">             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJe(), i));
</span><span class="cx"> 
</span><span class="cx">             // All good - put the value into the array.
</span><span class="cx">             __ link(inFastVector, __ label());
</span><span class="cx">             emitGetVirtualRegister(instruction[i + 3].u.operand, X86::eax, i);
</span><del>-            __ movl_rm(X86::eax, OBJECT_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*));
</del><ins>+            __ movl_rm(X86::eax, FIELD_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*));
</ins><span class="cx">             i += 4;
</span><span class="cx">             break;
</span><span class="cx">         }
</span><span class="lines">@@ -1624,10 +1629,10 @@
</span><span class="cx">                 if (!resultType.definitelyIsNumber()) {
</span><span class="cx">                     emitJumpSlowCaseIfNotJSCell(X86::eax, i, srcVReg);
</span><span class="cx">                     Structure* numberStructure = m_globalData-&gt;numberStructure.get();
</span><del>-                    __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(numberStructure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
</del><ins>+                    __ cmpl_i32m(reinterpret_cast&lt;unsigned&gt;(numberStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</ins><span class="cx">                     m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</span><span class="cx">                 }
</span><del>-                __ movsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
</del><ins>+                __ movsd_mr(FIELD_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
</ins><span class="cx">                 // We need 3 copies of the sign bit mask so we can assure alignment and pad for the 128bit load
</span><span class="cx">                 static double doubleSignBit[] = { -0.0, -0.0, -0.0 };
</span><span class="cx">                 __ xorpd_mr((void*)((((uintptr_t)doubleSignBit)+15)&amp;~15), X86::xmm0);
</span><span class="lines">@@ -1662,11 +1667,11 @@
</span><span class="cx">             // Check Structure of global object
</span><span class="cx">             __ movl_i32r(globalObject, X86::eax);
</span><span class="cx">             __ movl_mr(structureAddress, X86::edx);
</span><del>-            __ cmpl_rm(X86::edx, OBJECT_OFFSET(JSCell, m_structure), X86::eax);
</del><ins>+            __ cmpl_rm(X86::edx, FIELD_OFFSET(JSCell, m_structure), X86::eax);
</ins><span class="cx">             X86Assembler::JmpSrc noMatch = __ emitUnlinkedJne(); // Structures don't match
</span><span class="cx"> 
</span><span class="cx">             // Load cached property
</span><del>-            __ movl_mr(OBJECT_OFFSET(JSGlobalObject, m_propertyStorage), X86::eax, X86::eax);
</del><ins>+            __ movl_mr(FIELD_OFFSET(JSGlobalObject, m_propertyStorage), X86::eax, X86::eax);
</ins><span class="cx">             __ movl_mr(offsetAddr, X86::edx);
</span><span class="cx">             __ movl_mr(0, X86::eax, X86::edx, sizeof(JSValue*), X86::eax);
</span><span class="cx">             emitPutVirtualRegister(instruction[i + 1].u.operand);
</span><span class="lines">@@ -1748,8 +1753,8 @@
</span><span class="cx">             __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><span class="cx">             X86Assembler::JmpSrc isImmediate = __ emitUnlinkedJnz();
</span><span class="cx"> 
</span><del>-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
-            __ testl_i32m(MasqueradesAsUndefined, OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
</del><ins>+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ testl_i32m(MasqueradesAsUndefined, FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
</ins><span class="cx">             __ setnz_r(X86::eax);
</span><span class="cx"> 
</span><span class="cx">             X86Assembler::JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
</span><span class="lines">@@ -1778,8 +1783,8 @@
</span><span class="cx">             __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><span class="cx">             X86Assembler::JmpSrc isImmediate = __ emitUnlinkedJnz();
</span><span class="cx"> 
</span><del>-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
-            __ testl_i32m(MasqueradesAsUndefined, OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
</del><ins>+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ testl_i32m(MasqueradesAsUndefined, FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
</ins><span class="cx">             __ setz_r(X86::eax);
</span><span class="cx"> 
</span><span class="cx">             X86Assembler::JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
</span><span class="lines">@@ -2069,8 +2074,8 @@
</span><span class="cx"> 
</span><span class="cx">             emitJumpSlowCaseIfNotJSCell(X86::eax, i, srcVReg);
</span><span class="cx"> 
</span><del>-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
-            __ cmpl_i32m(NumberType, OBJECT_OFFSET(Structure, m_typeInfo.m_type), X86::ecx);
</del><ins>+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ cmpl_i32m(NumberType, FIELD_OFFSET(Structure, m_typeInfo.m_type), X86::ecx);
</ins><span class="cx">             
</span><span class="cx">             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
</span><span class="cx">             
</span><span class="lines">@@ -2222,8 +2227,8 @@
</span><span class="cx">             __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><span class="cx">             X86Assembler::JmpSrc isImmediate = __ emitUnlinkedJnz();
</span><span class="cx"> 
</span><del>-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
-            __ testl_i32m(MasqueradesAsUndefined, OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
</del><ins>+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ testl_i32m(MasqueradesAsUndefined, FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
</ins><span class="cx">             __ setnz_r(X86::eax);
</span><span class="cx"> 
</span><span class="cx">             X86Assembler::JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
</span><span class="lines">@@ -2252,8 +2257,8 @@
</span><span class="cx">             __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><span class="cx">             X86Assembler::JmpSrc isImmediate = __ emitUnlinkedJnz();
</span><span class="cx"> 
</span><del>-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
-            __ testl_i32m(MasqueradesAsUndefined, OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
</del><ins>+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ testl_i32m(MasqueradesAsUndefined, FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
</ins><span class="cx">             __ setz_r(X86::eax);
</span><span class="cx"> 
</span><span class="cx">             X86Assembler::JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
</span><span class="lines">@@ -2308,8 +2313,8 @@
</span><span class="cx">             emitGetVirtualRegister(instruction[i + 1].u.operand, X86::eax, i);
</span><span class="cx"> 
</span><span class="cx">             emitJumpSlowCaseIfNotJSCell(X86::eax, i);
</span><del>-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::edx);
-            __ testl_i32m(NeedsThisConversion, OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::edx);
</del><ins>+            __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::edx);
+            __ testl_i32m(NeedsThisConversion, FIELD_OFFSET(Structure, m_typeInfo.m_flags), X86::edx);
</ins><span class="cx">             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJnz(), i));
</span><span class="cx"> 
</span><span class="cx">             i += 2;
</span><span class="lines">@@ -2462,11 +2467,11 @@
</span><span class="cx">             // This is slow case that handles accesses to arrays above the fast cut-off.
</span><span class="cx">             // First, check if this is an access to the vector
</span><span class="cx">             __ link((++iter)-&gt;from, __ label());
</span><del>-            __ cmpl_rm(X86::edx, OBJECT_OFFSET(ArrayStorage, m_vectorLength), X86::ecx);
</del><ins>+            __ cmpl_rm(X86::edx, FIELD_OFFSET(ArrayStorage, m_vectorLength), X86::ecx);
</ins><span class="cx">             __ link(__ emitUnlinkedJbe(), beginGetByValSlow);
</span><span class="cx"> 
</span><span class="cx">             // okay, missed the fast region, but it is still in the vector.  Get the value.
</span><del>-            __ movl_mr(OBJECT_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*), X86::ecx);
</del><ins>+            __ movl_mr(FIELD_OFFSET(ArrayStorage, m_vector[0]), X86::ecx, X86::edx, sizeof(JSValue*), X86::ecx);
</ins><span class="cx">             // Check whether the value loaded is zero; if so we need to return undefined.
</span><span class="cx">             __ testl_rr(X86::ecx, X86::ecx);
</span><span class="cx">             __ link(__ emitUnlinkedJe(), beginGetByValSlow);
</span><span class="lines">@@ -3023,7 +3028,7 @@
</span><span class="cx"> 
</span><span class="cx">         emitGetCTIParam(CTI_ARGS_registerFile, X86::eax);
</span><span class="cx">         __ leal_mr(m_codeBlock-&gt;numCalleeRegisters * sizeof(Register), X86::edi, X86::edx);
</span><del>-        __ cmpl_mr(OBJECT_OFFSET(RegisterFile, m_end), X86::eax, X86::edx);
</del><ins>+        __ cmpl_mr(FIELD_OFFSET(RegisterFile, m_end), X86::eax, X86::edx);
</ins><span class="cx">         slowRegisterFileCheck = __ emitUnlinkedJg();
</span><span class="cx">         afterRegisterFileCheck = __ label();
</span><span class="cx">     }
</span><span class="lines">@@ -3106,11 +3111,11 @@
</span><span class="cx">     // Check eax is an object of the right Structure.
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><span class="cx">     X86Assembler::JmpSrc failureCases1 = __ emitUnlinkedJne();
</span><del>-    __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(structure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
</del><ins>+    __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</ins><span class="cx">     X86Assembler::JmpSrc failureCases2 = __ emitUnlinkedJne();
</span><span class="cx"> 
</span><span class="cx">     // Checks out okay! - getDirectOffset
</span><del>-    __ movl_mr(OBJECT_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
</del><ins>+    __ movl_mr(FIELD_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
</ins><span class="cx">     __ movl_mr(cachedOffset * sizeof(JSValue*), X86::eax, X86::eax);
</span><span class="cx">     __ ret();
</span><span class="cx"> 
</span><span class="lines">@@ -3142,7 +3147,7 @@
</span><span class="cx">     // check eax is an object of the right Structure.
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><span class="cx">     X86Assembler::JmpSrc failureCases1 = __ emitUnlinkedJne();
</span><del>-    __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(structure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
</del><ins>+    __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</ins><span class="cx">     X86Assembler::JmpSrc failureCases2 = __ emitUnlinkedJne();
</span><span class="cx"> 
</span><span class="cx">     // Check the prototype object's Structure had not changed.
</span><span class="lines">@@ -3185,7 +3190,7 @@
</span><span class="cx">     // check eax is an object of the right Structure.
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><span class="cx">     X86Assembler::JmpSrc failureCases1 = __ emitUnlinkedJne();
</span><del>-    __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(structure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
</del><ins>+    __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</ins><span class="cx">     X86Assembler::JmpSrc failureCases2 = __ emitUnlinkedJne();
</span><span class="cx"> 
</span><span class="cx">     // Check the prototype object's Structure had not changed.
</span><span class="lines">@@ -3220,7 +3225,7 @@
</span><span class="cx">     // Check eax is an object of the right Structure.
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><span class="cx">     bucketsOfFail.append(__ emitUnlinkedJne());
</span><del>-    __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(structure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
</del><ins>+    __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</ins><span class="cx">     bucketsOfFail.append(__ emitUnlinkedJne());
</span><span class="cx"> 
</span><span class="cx">     Structure* currStructure = structure;
</span><span class="lines">@@ -3260,11 +3265,11 @@
</span><span class="cx">     // check eax is an object of the right Structure.
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><span class="cx">     X86Assembler::JmpSrc failureCases1 = __ emitUnlinkedJne();
</span><del>-    __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(structure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
</del><ins>+    __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(structure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</ins><span class="cx">     X86Assembler::JmpSrc failureCases2 = __ emitUnlinkedJne();
</span><span class="cx"> 
</span><span class="cx">     // checks out okay! - putDirectOffset
</span><del>-    __ movl_mr(OBJECT_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
</del><ins>+    __ movl_mr(FIELD_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
</ins><span class="cx">     __ movl_rm(X86::edx, cachedOffset * sizeof(JSValue*), X86::eax);
</span><span class="cx">     __ ret();
</span><span class="cx"> 
</span><span class="lines">@@ -3300,16 +3305,16 @@
</span><span class="cx">     // check eax is an object of the right Structure.
</span><span class="cx">     __ testl_i32r(JSImmediate::TagMask, X86::eax);
</span><span class="cx">     failureCases.append(__ emitUnlinkedJne());
</span><del>-    __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(oldStructure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
</del><ins>+    __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(oldStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</ins><span class="cx">     failureCases.append(__ emitUnlinkedJne());
</span><span class="cx">     Vector&lt;X86Assembler::JmpSrc&gt; successCases;
</span><span class="cx"> 
</span><span class="cx">     //  ecx = baseObject
</span><del>-    __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
</del><ins>+    __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
</ins><span class="cx">     // proto(ecx) = baseObject-&gt;structure()-&gt;prototype()
</span><del>-    __ cmpl_i32m(ObjectType, OBJECT_OFFSET(Structure, m_typeInfo) + OBJECT_OFFSET(TypeInfo, m_type), X86::ecx);
</del><ins>+    __ cmpl_i32m(ObjectType, FIELD_OFFSET(Structure, m_typeInfo) + FIELD_OFFSET(TypeInfo, m_type), X86::ecx);
</ins><span class="cx">     failureCases.append(__ emitUnlinkedJne());
</span><del>-    __ movl_mr(OBJECT_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
</del><ins>+    __ movl_mr(FIELD_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
</ins><span class="cx">     
</span><span class="cx">     // ecx = baseObject-&gt;m_structure
</span><span class="cx">     for (RefPtr&lt;Structure&gt;* it = chain-&gt;head(); *it; ++it) {
</span><span class="lines">@@ -3318,13 +3323,13 @@
</span><span class="cx">         successCases.append(__ emitUnlinkedJe());
</span><span class="cx"> 
</span><span class="cx">         // Check the structure id
</span><del>-        __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(it-&gt;get()), OBJECT_OFFSET(JSCell, m_structure), X86::ecx);
</del><ins>+        __ cmpl_i32m(reinterpret_cast&lt;uint32_t&gt;(it-&gt;get()), FIELD_OFFSET(JSCell, m_structure), X86::ecx);
</ins><span class="cx">         failureCases.append(__ emitUnlinkedJne());
</span><span class="cx">         
</span><del>-        __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::ecx, X86::ecx);
-        __ cmpl_i32m(ObjectType, OBJECT_OFFSET(Structure, m_typeInfo) + OBJECT_OFFSET(TypeInfo, m_type), X86::ecx);
</del><ins>+        __ movl_mr(FIELD_OFFSET(JSCell, m_structure), X86::ecx, X86::ecx);
+        __ cmpl_i32m(ObjectType, FIELD_OFFSET(Structure, m_typeInfo) + FIELD_OFFSET(TypeInfo, m_type), X86::ecx);
</ins><span class="cx">         failureCases.append(__ emitUnlinkedJne());
</span><del>-        __ movl_mr(OBJECT_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
</del><ins>+        __ movl_mr(FIELD_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     failureCases.append(__ emitUnlinkedJne());
</span><span class="lines">@@ -3348,10 +3353,10 @@
</span><span class="cx">     // codeblock should ensure oldStructure-&gt;m_refCount &gt; 0
</span><span class="cx">     __ subl_i8m(1, reinterpret_cast&lt;void*&gt;(oldStructure));
</span><span class="cx">     __ addl_i8m(1, reinterpret_cast&lt;void*&gt;(newStructure));
</span><del>-    __ movl_i32m(reinterpret_cast&lt;uint32_t&gt;(newStructure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
</del><ins>+    __ movl_i32m(reinterpret_cast&lt;uint32_t&gt;(newStructure), FIELD_OFFSET(JSCell, m_structure), X86::eax);
</ins><span class="cx"> 
</span><span class="cx">     // write the value
</span><del>-    __ movl_mr(OBJECT_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
</del><ins>+    __ movl_mr(FIELD_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
</ins><span class="cx">     __ movl_rm(X86::edx, cachedOffset * sizeof(JSValue*), X86::eax);
</span><span class="cx"> 
</span><span class="cx">     __ ret();
</span><span class="lines">@@ -3414,8 +3419,8 @@
</span><span class="cx">     X86Assembler::JmpSrc array_failureCases2 = __ emitUnlinkedJne();
</span><span class="cx"> 
</span><span class="cx">     // Checks out okay! - get the length from the storage
</span><del>-    __ movl_mr(OBJECT_OFFSET(JSArray, m_storage), X86::eax, X86::eax);
-    __ movl_mr(OBJECT_OFFSET(ArrayStorage, m_length), X86::eax, X86::eax);
</del><ins>+    __ movl_mr(FIELD_OFFSET(JSArray, m_storage), X86::eax, X86::eax);
+    __ movl_mr(FIELD_OFFSET(ArrayStorage, m_length), X86::eax, X86::eax);
</ins><span class="cx"> 
</span><span class="cx">     __ addl_rr(X86::eax, X86::eax);
</span><span class="cx">     X86Assembler::JmpSrc array_failureCases3 = __ emitUnlinkedJo();
</span><span class="lines">@@ -3434,8 +3439,8 @@
</span><span class="cx">     X86Assembler::JmpSrc string_failureCases2 = __ emitUnlinkedJne();
</span><span class="cx"> 
</span><span class="cx">     // Checks out okay! - get the length from the Ustring.
</span><del>-    __ movl_mr(OBJECT_OFFSET(JSString, m_value) + OBJECT_OFFSET(UString, m_rep), X86::eax, X86::eax);
-    __ movl_mr(OBJECT_OFFSET(UString::Rep, len), X86::eax, X86::eax);
</del><ins>+    __ movl_mr(FIELD_OFFSET(JSString, m_value) + FIELD_OFFSET(UString, m_rep), X86::eax, X86::eax);
+    __ movl_mr(FIELD_OFFSET(UString::Rep, len), X86::eax, X86::eax);
</ins><span class="cx"> 
</span><span class="cx">     __ addl_rr(X86::eax, X86::eax);
</span><span class="cx">     X86Assembler::JmpSrc string_failureCases3 = __ emitUnlinkedJo();
</span><span class="lines">@@ -3448,8 +3453,8 @@
</span><span class="cx">     X86Assembler::JmpDst virtualCallPreLinkBegin = __ align(16);
</span><span class="cx"> 
</span><span class="cx">     // Load the callee CodeBlock* into eax
</span><del>-    __ movl_mr(OBJECT_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
-    __ movl_mr(OBJECT_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
</del><ins>+    __ movl_mr(FIELD_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
+    __ movl_mr(FIELD_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
</ins><span class="cx">     __ testl_rr(X86::eax, X86::eax);
</span><span class="cx">     X86Assembler::JmpSrc hasCodeBlock1 = __ emitUnlinkedJne();
</span><span class="cx">     __ popl_r(X86::ebx);
</span><span class="lines">@@ -3462,7 +3467,7 @@
</span><span class="cx">     __ link(hasCodeBlock1, __ label());
</span><span class="cx"> 
</span><span class="cx">     // Check argCount matches callee arity.
</span><del>-    __ cmpl_rm(X86::edx, OBJECT_OFFSET(CodeBlock, numParameters), X86::eax);
</del><ins>+    __ cmpl_rm(X86::edx, FIELD_OFFSET(CodeBlock, numParameters), X86::eax);
</ins><span class="cx">     X86Assembler::JmpSrc arityCheckOkay1 = __ emitUnlinkedJe();
</span><span class="cx">     __ popl_r(X86::ebx);
</span><span class="cx">     emitPutCTIArg(X86::ebx, 4);
</span><span class="lines">@@ -3490,8 +3495,8 @@
</span><span class="cx">     X86Assembler::JmpDst virtualCallLinkBegin = __ align(16);
</span><span class="cx"> 
</span><span class="cx">     // Load the callee CodeBlock* into eax
</span><del>-    __ movl_mr(OBJECT_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
-    __ movl_mr(OBJECT_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
</del><ins>+    __ movl_mr(FIELD_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
+    __ movl_mr(FIELD_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
</ins><span class="cx">     __ testl_rr(X86::eax, X86::eax);
</span><span class="cx">     X86Assembler::JmpSrc hasCodeBlock2 = __ emitUnlinkedJne();
</span><span class="cx">     __ popl_r(X86::ebx);
</span><span class="lines">@@ -3504,7 +3509,7 @@
</span><span class="cx">     __ link(hasCodeBlock2, __ label());
</span><span class="cx"> 
</span><span class="cx">     // Check argCount matches callee arity.
</span><del>-    __ cmpl_rm(X86::edx, OBJECT_OFFSET(CodeBlock, numParameters), X86::eax);
</del><ins>+    __ cmpl_rm(X86::edx, FIELD_OFFSET(CodeBlock, numParameters), X86::eax);
</ins><span class="cx">     X86Assembler::JmpSrc arityCheckOkay2 = __ emitUnlinkedJe();
</span><span class="cx">     __ popl_r(X86::ebx);
</span><span class="cx">     emitPutCTIArg(X86::ebx, 4);
</span><span class="lines">@@ -3532,8 +3537,8 @@
</span><span class="cx">     X86Assembler::JmpDst virtualCallBegin = __ align(16);
</span><span class="cx"> 
</span><span class="cx">     // Load the callee CodeBlock* into eax
</span><del>-    __ movl_mr(OBJECT_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
-    __ movl_mr(OBJECT_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
</del><ins>+    __ movl_mr(FIELD_OFFSET(JSFunction, m_body), X86::ecx, X86::eax);
+    __ movl_mr(FIELD_OFFSET(FunctionBodyNode, m_code), X86::eax, X86::eax);
</ins><span class="cx">     __ testl_rr(X86::eax, X86::eax);
</span><span class="cx">     X86Assembler::JmpSrc hasCodeBlock3 = __ emitUnlinkedJne();
</span><span class="cx">     __ popl_r(X86::ebx);
</span><span class="lines">@@ -3546,7 +3551,7 @@
</span><span class="cx">     __ link(hasCodeBlock3, __ label());
</span><span class="cx"> 
</span><span class="cx">     // Check argCount matches callee arity.
</span><del>-    __ cmpl_rm(X86::edx, OBJECT_OFFSET(CodeBlock, numParameters), X86::eax);
</del><ins>+    __ cmpl_rm(X86::edx, FIELD_OFFSET(CodeBlock, numParameters), X86::eax);
</ins><span class="cx">     X86Assembler::JmpSrc arityCheckOkay3 = __ emitUnlinkedJe();
</span><span class="cx">     __ popl_r(X86::ebx);
</span><span class="cx">     emitPutCTIArg(X86::ebx, 4);
</span><span class="lines">@@ -3563,7 +3568,7 @@
</span><span class="cx">     compileOpCallInitializeCallFrame();
</span><span class="cx"> 
</span><span class="cx">     // load ctiCode from the new codeBlock.
</span><del>-    __ movl_mr(OBJECT_OFFSET(CodeBlock, ctiCode), X86::eax, X86::eax);
</del><ins>+    __ movl_mr(FIELD_OFFSET(CodeBlock, ctiCode), X86::eax, X86::eax);
</ins><span class="cx"> 
</span><span class="cx">     __ jmp_r(X86::eax);
</span><span class="cx"> 
</span><span class="lines">@@ -3639,8 +3644,8 @@
</span><span class="cx">     X86Assembler::JmpSrc failureCases2 = __ emitUnlinkedJne();
</span><span class="cx"> 
</span><span class="cx">     // Checks out okay! - get the length from the storage
</span><del>-    __ movl_mr(OBJECT_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
-    __ movl_mr(OBJECT_OFFSET(ArrayStorage, m_length), X86::ecx, X86::ecx);
</del><ins>+    __ movl_mr(FIELD_OFFSET(JSArray, m_storage), X86::eax, X86::ecx);
+    __ movl_mr(FIELD_OFFSET(ArrayStorage, m_length), X86::ecx, X86::ecx);
</ins><span class="cx"> 
</span><span class="cx">     __ cmpl_i32r(JSImmediate::maxImmediateInt, X86::ecx);
</span><span class="cx">     X86Assembler::JmpSrc failureCases3 = __ emitUnlinkedJa();
</span><span class="lines">@@ -3674,15 +3679,15 @@
</span><span class="cx"> 
</span><span class="cx"> void CTI::emitGetVariableObjectRegister(X86Assembler::RegisterID variableObject, int index, X86Assembler::RegisterID dst)
</span><span class="cx"> {
</span><del>-    __ movl_mr(JSVariableObject::offsetOf_d(), variableObject, dst);
-    __ movl_mr(JSVariableObject::offsetOf_Data_registers(), dst, dst);
</del><ins>+    __ movl_mr(FIELD_OFFSET(JSVariableObject, d), variableObject, dst);
+    __ movl_mr(FIELD_OFFSET(JSVariableObject::JSVariableObjectData, registers), dst, dst);
</ins><span class="cx">     __ movl_mr(index * sizeof(Register), dst, dst);
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void CTI::emitPutVariableObjectRegister(X86Assembler::RegisterID src, X86Assembler::RegisterID variableObject, int index)
</span><span class="cx"> {
</span><del>-    __ movl_mr(JSVariableObject::offsetOf_d(), variableObject, variableObject);
-    __ movl_mr(JSVariableObject::offsetOf_Data_registers(), variableObject, variableObject);
</del><ins>+    __ movl_mr(FIELD_OFFSET(JSVariableObject, d), variableObject, variableObject);
+    __ movl_mr(FIELD_OFFSET(JSVariableObject::JSVariableObjectData, registers), variableObject, variableObject);
</ins><span class="cx">     __ movl_rm(src, index * sizeof(Register), variableObject);
</span><span class="cx"> }
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkJavaScriptCoreruntimeJSValueh"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/runtime/JSValue.h (38466 => 38467)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/runtime/JSValue.h        2008-11-17 02:40:28 UTC (rev 38466)
+++ trunk/JavaScriptCore/runtime/JSValue.h        2008-11-17 03:02:43 UTC (rev 38467)
</span><span class="lines">@@ -29,10 +29,6 @@
</span><span class="cx"> #include &quot;UString.h&quot;
</span><span class="cx"> #include &lt;stddef.h&gt; // for size_t
</span><span class="cx"> 
</span><del>-// The magic number 0x4000 is not important here, it is being subtracted back out (avoiding using zero since this
-// can have unexpected effects in this type of macro, particularly where multiple-inheritance is involved).
-#define OBJECT_OFFSET(class, member) (reinterpret_cast&lt;ptrdiff_t&gt;(&amp;(reinterpret_cast&lt;class*&gt;(0x4000)-&gt;member)) - 0x4000)
-
</del><span class="cx"> namespace JSC {
</span><span class="cx"> 
</span><span class="cx">     class Identifier;
</span></span></pre></div>
<a id="trunkJavaScriptCoreruntimeJSVariableObjecth"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/runtime/JSVariableObject.h (38466 => 38467)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/runtime/JSVariableObject.h        2008-11-17 02:40:28 UTC (rev 38466)
+++ trunk/JavaScriptCore/runtime/JSVariableObject.h        2008-11-17 03:02:43 UTC (rev 38467)
</span><span class="lines">@@ -41,6 +41,8 @@
</span><span class="cx">     class Register;
</span><span class="cx"> 
</span><span class="cx">     class JSVariableObject : public JSObject {
</span><ins>+        friend class CTI;
+
</ins><span class="cx">     public:
</span><span class="cx">         SymbolTable&amp; symbolTable() const { return *d-&gt;symbolTable; }
</span><span class="cx"> 
</span><span class="lines">@@ -72,11 +74,6 @@
</span><span class="cx">             Register* registers; // &quot;r&quot; in the register file.
</span><span class="cx">             OwnArrayPtr&lt;Register&gt; registerArray; // Independent copy of registers, used when a variable object copies its registers out of the register file.
</span><span class="cx"> 
</span><del>-            static inline ptrdiff_t offsetOf_registers()
-            {
-                return OBJECT_OFFSET(JSVariableObjectData, registers);
-            }
-
</del><span class="cx">         private:
</span><span class="cx">             JSVariableObjectData(const JSVariableObjectData&amp;);
</span><span class="cx">             JSVariableObjectData&amp; operator=(const JSVariableObjectData&amp;);
</span><span class="lines">@@ -97,17 +94,6 @@
</span><span class="cx">         bool symbolTablePutWithAttributes(const Identifier&amp;, JSValue*, unsigned attributes);
</span><span class="cx"> 
</span><span class="cx">         JSVariableObjectData* d;
</span><del>-
-    public:
-        static inline ptrdiff_t offsetOf_d()
-        {
-            return OBJECT_OFFSET(JSVariableObject, d);
-        }
-
-        static inline ptrdiff_t offsetOf_Data_registers()
-        {
-            return JSVariableObjectData::offsetOf_registers();
-        }
</del><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     inline bool JSVariableObject::symbolTableGet(const Identifier&amp; propertyName, PropertySlot&amp; slot)
</span></span></pre>
</div>
</div>

</body>
</html>