<!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>[38428] 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/38428">38428</a></dd>
<dt>Author</dt> <dd>ggaren@apple.com</dd>
<dt>Date</dt> <dd>2008-11-15 13:37:49 -0800 (Sat, 15 Nov 2008)</dd>
</dl>

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

        Suggested by Maciej Stachowiak.
        
        Reverted most &quot;opcode&quot; =&gt; &quot;bytecode&quot; renames. We use &quot;bytecode&quot; as a
        mass noun to refer to a stream of instructions. Each instruction may be
        an opcode or an operand.

        * VM/CTI.cpp:
        (JSC::CTI::emitCTICall):
        (JSC::CTI::compileOpCall):
        (JSC::CTI::compileBinaryArithOp):
        (JSC::CTI::compileBinaryArithOpSlowCase):
        (JSC::CTI::privateCompileMainPass):
        (JSC::CTI::privateCompileSlowCases):
        (JSC::CTI::privateCompile):
        * VM/CTI.h:
        * VM/CodeBlock.cpp:
        (JSC::CodeBlock::printStructureIDs):
        (JSC::CodeBlock::dump):
        (JSC::CodeBlock::derefStructureIDs):
        (JSC::CodeBlock::refStructureIDs):
        * VM/CodeBlock.h:
        * VM/ExceptionHelpers.cpp:
        (JSC::createNotAnObjectError):
        * VM/Instruction.h:
        (JSC::Instruction::Instruction):
        (JSC::Instruction::):
        * VM/Machine.cpp:
        (JSC::BytecodeInterpreter::isOpcode):
        (JSC::BytecodeInterpreter::throwException):
        (JSC::BytecodeInterpreter::tryCachePutByID):
        (JSC::BytecodeInterpreter::uncachePutByID):
        (JSC::BytecodeInterpreter::tryCacheGetByID):
        (JSC::BytecodeInterpreter::uncacheGetByID):
        (JSC::BytecodeInterpreter::privateExecute):
        (JSC::BytecodeInterpreter::tryCTICachePutByID):
        (JSC::BytecodeInterpreter::tryCTICacheGetByID):
        * VM/Machine.h:
        (JSC::BytecodeInterpreter::getOpcode):
        (JSC::BytecodeInterpreter::getOpcodeID):
        (JSC::BytecodeInterpreter::isCallBytecode):
        * VM/Opcode.cpp:
        (JSC::):
        (JSC::OpcodeStats::OpcodeStats):
        (JSC::compareOpcodeIndices):
        (JSC::compareOpcodePairIndices):
        (JSC::OpcodeStats::~OpcodeStats):
        (JSC::OpcodeStats::recordInstruction):
        (JSC::OpcodeStats::resetLastInstruction):
        * VM/Opcode.h:
        (JSC::):
        (JSC::padOpcodeName):
        * VM/SamplingTool.cpp:
        (JSC::ScopeSampleRecord::sample):
        (JSC::SamplingTool::run):
        (JSC::compareOpcodeIndicesSampling):
        (JSC::SamplingTool::dump):
        * VM/SamplingTool.h:
        (JSC::ScopeSampleRecord::ScopeSampleRecord):
        (JSC::SamplingTool::SamplingTool):
        * bytecompiler/CodeGenerator.cpp:
        (JSC::BytecodeGenerator::BytecodeGenerator):
        (JSC::BytecodeGenerator::emitLabel):
        (JSC::BytecodeGenerator::emitOpcode):
        (JSC::BytecodeGenerator::emitJump):
        (JSC::BytecodeGenerator::emitJumpIfTrue):
        (JSC::BytecodeGenerator::emitJumpIfFalse):
        (JSC::BytecodeGenerator::emitMove):
        (JSC::BytecodeGenerator::emitUnaryOp):
        (JSC::BytecodeGenerator::emitPreInc):
        (JSC::BytecodeGenerator::emitPreDec):
        (JSC::BytecodeGenerator::emitPostInc):
        (JSC::BytecodeGenerator::emitPostDec):
        (JSC::BytecodeGenerator::emitBinaryOp):
        (JSC::BytecodeGenerator::emitEqualityOp):
        (JSC::BytecodeGenerator::emitUnexpectedLoad):
        (JSC::BytecodeGenerator::emitInstanceOf):
        (JSC::BytecodeGenerator::emitResolve):
        (JSC::BytecodeGenerator::emitGetScopedVar):
        (JSC::BytecodeGenerator::emitPutScopedVar):
        (JSC::BytecodeGenerator::emitResolveBase):
        (JSC::BytecodeGenerator::emitResolveWithBase):
        (JSC::BytecodeGenerator::emitResolveFunction):
        (JSC::BytecodeGenerator::emitGetById):
        (JSC::BytecodeGenerator::emitPutById):
        (JSC::BytecodeGenerator::emitPutGetter):
        (JSC::BytecodeGenerator::emitPutSetter):
        (JSC::BytecodeGenerator::emitDeleteById):
        (JSC::BytecodeGenerator::emitGetByVal):
        (JSC::BytecodeGenerator::emitPutByVal):
        (JSC::BytecodeGenerator::emitDeleteByVal):
        (JSC::BytecodeGenerator::emitPutByIndex):
        (JSC::BytecodeGenerator::emitNewObject):
        (JSC::BytecodeGenerator::emitNewArray):
        (JSC::BytecodeGenerator::emitNewFunction):
        (JSC::BytecodeGenerator::emitNewRegExp):
        (JSC::BytecodeGenerator::emitNewFunctionExpression):
        (JSC::BytecodeGenerator::emitCall):
        (JSC::BytecodeGenerator::emitReturn):
        (JSC::BytecodeGenerator::emitUnaryNoDstOp):
        (JSC::BytecodeGenerator::emitConstruct):
        (JSC::BytecodeGenerator::emitPopScope):
        (JSC::BytecodeGenerator::emitDebugHook):
        (JSC::BytecodeGenerator::emitComplexJumpScopes):
        (JSC::BytecodeGenerator::emitJumpScopes):
        (JSC::BytecodeGenerator::emitNextPropertyName):
        (JSC::BytecodeGenerator::emitCatch):
        (JSC::BytecodeGenerator::emitNewError):
        (JSC::BytecodeGenerator::emitJumpSubroutine):
        (JSC::BytecodeGenerator::emitSubroutineReturn):
        (JSC::BytecodeGenerator::emitPushNewScope):
        (JSC::BytecodeGenerator::beginSwitch):
        * bytecompiler/CodeGenerator.h:
        * jsc.cpp:
        (runWithScripts):
        * masm/X86Assembler.h:
        (JSC::X86Assembler::):
        (JSC::X86Assembler::emitModRm_opr):
        (JSC::X86Assembler::emitModRm_opr_Unchecked):
        (JSC::X86Assembler::emitModRm_opm):
        (JSC::X86Assembler::emitModRm_opm_Unchecked):
        (JSC::X86Assembler::emitModRm_opmsib):
        * parser/Nodes.cpp:
        (JSC::UnaryOpNode::emitBytecode):
        (JSC::BinaryOpNode::emitBytecode):
        (JSC::ReverseBinaryOpNode::emitBytecode):
        (JSC::ThrowableBinaryOpNode::emitBytecode):
        (JSC::emitReadModifyAssignment):
        (JSC::ScopeNode::ScopeNode):
        * parser/Nodes.h:
        (JSC::UnaryPlusNode::):
        (JSC::NegateNode::):
        (JSC::BitwiseNotNode::):
        (JSC::LogicalNotNode::):
        (JSC::MultNode::):
        (JSC::DivNode::):
        (JSC::ModNode::):
        (JSC::AddNode::):
        (JSC::SubNode::):
        (JSC::LeftShiftNode::):
        (JSC::RightShiftNode::):
        (JSC::UnsignedRightShiftNode::):
        (JSC::LessNode::):
        (JSC::GreaterNode::):
        (JSC::LessEqNode::):
        (JSC::GreaterEqNode::):
        (JSC::InstanceOfNode::):
        (JSC::InNode::):
        (JSC::EqualNode::):
        (JSC::NotEqualNode::):
        (JSC::StrictEqualNode::):
        (JSC::NotStrictEqualNode::):
        (JSC::BitAndNode::):
        (JSC::BitOrNode::):
        (JSC::BitXOrNode::):
        * runtime/StructureID.cpp:
        (JSC::StructureID::fromDictionaryTransition):
        * wtf/Platform.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="#trunkJavaScriptCoreVMCTIh">trunk/JavaScriptCore/VM/CTI.h</a></li>
<li><a href="#trunkJavaScriptCoreVMCodeBlockcpp">trunk/JavaScriptCore/VM/CodeBlock.cpp</a></li>
<li><a href="#trunkJavaScriptCoreVMCodeBlockh">trunk/JavaScriptCore/VM/CodeBlock.h</a></li>
<li><a href="#trunkJavaScriptCoreVMExceptionHelperscpp">trunk/JavaScriptCore/VM/ExceptionHelpers.cpp</a></li>
<li><a href="#trunkJavaScriptCoreVMInstructionh">trunk/JavaScriptCore/VM/Instruction.h</a></li>
<li><a href="#trunkJavaScriptCoreVMMachinecpp">trunk/JavaScriptCore/VM/Machine.cpp</a></li>
<li><a href="#trunkJavaScriptCoreVMMachineh">trunk/JavaScriptCore/VM/Machine.h</a></li>
<li><a href="#trunkJavaScriptCoreVMOpcodecpp">trunk/JavaScriptCore/VM/Opcode.cpp</a></li>
<li><a href="#trunkJavaScriptCoreVMOpcodeh">trunk/JavaScriptCore/VM/Opcode.h</a></li>
<li><a href="#trunkJavaScriptCoreVMSamplingToolcpp">trunk/JavaScriptCore/VM/SamplingTool.cpp</a></li>
<li><a href="#trunkJavaScriptCoreVMSamplingToolh">trunk/JavaScriptCore/VM/SamplingTool.h</a></li>
<li><a href="#trunkJavaScriptCorebytecompilerCodeGeneratorcpp">trunk/JavaScriptCore/bytecompiler/CodeGenerator.cpp</a></li>
<li><a href="#trunkJavaScriptCorebytecompilerCodeGeneratorh">trunk/JavaScriptCore/bytecompiler/CodeGenerator.h</a></li>
<li><a href="#trunkJavaScriptCorejsccpp">trunk/JavaScriptCore/jsc.cpp</a></li>
<li><a href="#trunkJavaScriptCoremasmX86Assemblerh">trunk/JavaScriptCore/masm/X86Assembler.h</a></li>
<li><a href="#trunkJavaScriptCoreparserNodescpp">trunk/JavaScriptCore/parser/Nodes.cpp</a></li>
<li><a href="#trunkJavaScriptCoreparserNodesh">trunk/JavaScriptCore/parser/Nodes.h</a></li>
<li><a href="#trunkJavaScriptCoreruntimeStructureIDcpp">trunk/JavaScriptCore/runtime/StructureID.cpp</a></li>
<li><a href="#trunkJavaScriptCorewtfPlatformh">trunk/JavaScriptCore/wtf/Platform.h</a></li>
</ul>

</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/ChangeLog (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/ChangeLog        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/ChangeLog        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -1,5 +1,165 @@
</span><span class="cx"> 2008-11-15  Geoffrey Garen  &lt;ggaren@apple.com&gt;
</span><span class="cx"> 
</span><ins>+        Suggested by Maciej Stachowiak.
+        
+        Reverted most &quot;opcode&quot; =&gt; &quot;bytecode&quot; renames. We use &quot;bytecode&quot; as a
+        mass noun to refer to a stream of instructions. Each instruction may be
+        an opcode or an operand.
+
+        * VM/CTI.cpp:
+        (JSC::CTI::emitCTICall):
+        (JSC::CTI::compileOpCall):
+        (JSC::CTI::compileBinaryArithOp):
+        (JSC::CTI::compileBinaryArithOpSlowCase):
+        (JSC::CTI::privateCompileMainPass):
+        (JSC::CTI::privateCompileSlowCases):
+        (JSC::CTI::privateCompile):
+        * VM/CTI.h:
+        * VM/CodeBlock.cpp:
+        (JSC::CodeBlock::printStructureIDs):
+        (JSC::CodeBlock::dump):
+        (JSC::CodeBlock::derefStructureIDs):
+        (JSC::CodeBlock::refStructureIDs):
+        * VM/CodeBlock.h:
+        * VM/ExceptionHelpers.cpp:
+        (JSC::createNotAnObjectError):
+        * VM/Instruction.h:
+        (JSC::Instruction::Instruction):
+        (JSC::Instruction::):
+        * VM/Machine.cpp:
+        (JSC::BytecodeInterpreter::isOpcode):
+        (JSC::BytecodeInterpreter::throwException):
+        (JSC::BytecodeInterpreter::tryCachePutByID):
+        (JSC::BytecodeInterpreter::uncachePutByID):
+        (JSC::BytecodeInterpreter::tryCacheGetByID):
+        (JSC::BytecodeInterpreter::uncacheGetByID):
+        (JSC::BytecodeInterpreter::privateExecute):
+        (JSC::BytecodeInterpreter::tryCTICachePutByID):
+        (JSC::BytecodeInterpreter::tryCTICacheGetByID):
+        * VM/Machine.h:
+        (JSC::BytecodeInterpreter::getOpcode):
+        (JSC::BytecodeInterpreter::getOpcodeID):
+        (JSC::BytecodeInterpreter::isCallBytecode):
+        * VM/Opcode.cpp:
+        (JSC::):
+        (JSC::OpcodeStats::OpcodeStats):
+        (JSC::compareOpcodeIndices):
+        (JSC::compareOpcodePairIndices):
+        (JSC::OpcodeStats::~OpcodeStats):
+        (JSC::OpcodeStats::recordInstruction):
+        (JSC::OpcodeStats::resetLastInstruction):
+        * VM/Opcode.h:
+        (JSC::):
+        (JSC::padOpcodeName):
+        * VM/SamplingTool.cpp:
+        (JSC::ScopeSampleRecord::sample):
+        (JSC::SamplingTool::run):
+        (JSC::compareOpcodeIndicesSampling):
+        (JSC::SamplingTool::dump):
+        * VM/SamplingTool.h:
+        (JSC::ScopeSampleRecord::ScopeSampleRecord):
+        (JSC::SamplingTool::SamplingTool):
+        * bytecompiler/CodeGenerator.cpp:
+        (JSC::BytecodeGenerator::BytecodeGenerator):
+        (JSC::BytecodeGenerator::emitLabel):
+        (JSC::BytecodeGenerator::emitOpcode):
+        (JSC::BytecodeGenerator::emitJump):
+        (JSC::BytecodeGenerator::emitJumpIfTrue):
+        (JSC::BytecodeGenerator::emitJumpIfFalse):
+        (JSC::BytecodeGenerator::emitMove):
+        (JSC::BytecodeGenerator::emitUnaryOp):
+        (JSC::BytecodeGenerator::emitPreInc):
+        (JSC::BytecodeGenerator::emitPreDec):
+        (JSC::BytecodeGenerator::emitPostInc):
+        (JSC::BytecodeGenerator::emitPostDec):
+        (JSC::BytecodeGenerator::emitBinaryOp):
+        (JSC::BytecodeGenerator::emitEqualityOp):
+        (JSC::BytecodeGenerator::emitUnexpectedLoad):
+        (JSC::BytecodeGenerator::emitInstanceOf):
+        (JSC::BytecodeGenerator::emitResolve):
+        (JSC::BytecodeGenerator::emitGetScopedVar):
+        (JSC::BytecodeGenerator::emitPutScopedVar):
+        (JSC::BytecodeGenerator::emitResolveBase):
+        (JSC::BytecodeGenerator::emitResolveWithBase):
+        (JSC::BytecodeGenerator::emitResolveFunction):
+        (JSC::BytecodeGenerator::emitGetById):
+        (JSC::BytecodeGenerator::emitPutById):
+        (JSC::BytecodeGenerator::emitPutGetter):
+        (JSC::BytecodeGenerator::emitPutSetter):
+        (JSC::BytecodeGenerator::emitDeleteById):
+        (JSC::BytecodeGenerator::emitGetByVal):
+        (JSC::BytecodeGenerator::emitPutByVal):
+        (JSC::BytecodeGenerator::emitDeleteByVal):
+        (JSC::BytecodeGenerator::emitPutByIndex):
+        (JSC::BytecodeGenerator::emitNewObject):
+        (JSC::BytecodeGenerator::emitNewArray):
+        (JSC::BytecodeGenerator::emitNewFunction):
+        (JSC::BytecodeGenerator::emitNewRegExp):
+        (JSC::BytecodeGenerator::emitNewFunctionExpression):
+        (JSC::BytecodeGenerator::emitCall):
+        (JSC::BytecodeGenerator::emitReturn):
+        (JSC::BytecodeGenerator::emitUnaryNoDstOp):
+        (JSC::BytecodeGenerator::emitConstruct):
+        (JSC::BytecodeGenerator::emitPopScope):
+        (JSC::BytecodeGenerator::emitDebugHook):
+        (JSC::BytecodeGenerator::emitComplexJumpScopes):
+        (JSC::BytecodeGenerator::emitJumpScopes):
+        (JSC::BytecodeGenerator::emitNextPropertyName):
+        (JSC::BytecodeGenerator::emitCatch):
+        (JSC::BytecodeGenerator::emitNewError):
+        (JSC::BytecodeGenerator::emitJumpSubroutine):
+        (JSC::BytecodeGenerator::emitSubroutineReturn):
+        (JSC::BytecodeGenerator::emitPushNewScope):
+        (JSC::BytecodeGenerator::beginSwitch):
+        * bytecompiler/CodeGenerator.h:
+        * jsc.cpp:
+        (runWithScripts):
+        * masm/X86Assembler.h:
+        (JSC::X86Assembler::):
+        (JSC::X86Assembler::emitModRm_opr):
+        (JSC::X86Assembler::emitModRm_opr_Unchecked):
+        (JSC::X86Assembler::emitModRm_opm):
+        (JSC::X86Assembler::emitModRm_opm_Unchecked):
+        (JSC::X86Assembler::emitModRm_opmsib):
+        * parser/Nodes.cpp:
+        (JSC::UnaryOpNode::emitBytecode):
+        (JSC::BinaryOpNode::emitBytecode):
+        (JSC::ReverseBinaryOpNode::emitBytecode):
+        (JSC::ThrowableBinaryOpNode::emitBytecode):
+        (JSC::emitReadModifyAssignment):
+        (JSC::ScopeNode::ScopeNode):
+        * parser/Nodes.h:
+        (JSC::UnaryPlusNode::):
+        (JSC::NegateNode::):
+        (JSC::BitwiseNotNode::):
+        (JSC::LogicalNotNode::):
+        (JSC::MultNode::):
+        (JSC::DivNode::):
+        (JSC::ModNode::):
+        (JSC::AddNode::):
+        (JSC::SubNode::):
+        (JSC::LeftShiftNode::):
+        (JSC::RightShiftNode::):
+        (JSC::UnsignedRightShiftNode::):
+        (JSC::LessNode::):
+        (JSC::GreaterNode::):
+        (JSC::LessEqNode::):
+        (JSC::GreaterEqNode::):
+        (JSC::InstanceOfNode::):
+        (JSC::InNode::):
+        (JSC::EqualNode::):
+        (JSC::NotEqualNode::):
+        (JSC::StrictEqualNode::):
+        (JSC::NotStrictEqualNode::):
+        (JSC::BitAndNode::):
+        (JSC::BitOrNode::):
+        (JSC::BitXOrNode::):
+        * runtime/StructureID.cpp:
+        (JSC::StructureID::fromDictionaryTransition):
+        * wtf/Platform.h:
+
+2008-11-15  Geoffrey Garen  &lt;ggaren@apple.com&gt;
+
</ins><span class="cx">         Reviewed by Sam Weinig.
</span><span class="cx">         
</span><span class="cx">         Renames:
</span></span></pre></div>
<a id="trunkJavaScriptCoreVMCTIcpp"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/VM/CTI.cpp (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/VM/CTI.cpp        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/VM/CTI.cpp        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -387,7 +387,7 @@
</span><span class="cx"> 
</span><span class="cx"> ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_j helper)
</span><span class="cx"> {
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     m_jit.movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, true), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="cx"> #else
</span><span class="cx">     UNUSED_PARAM(vPC);
</span><span class="lines">@@ -396,7 +396,7 @@
</span><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><span class="cx">     X86Assembler::JmpSrc call = m_jit.emitCall();
</span><span class="cx">     m_calls.append(CallRecord(call, helper, bytecodeIndex));
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     m_jit.movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, false), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="cx"> #endif
</span><span class="cx">     killLastResultRegister();
</span><span class="lines">@@ -406,7 +406,7 @@
</span><span class="cx"> 
</span><span class="cx"> ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_o helper)
</span><span class="cx"> {
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     m_jit.movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, true), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="cx"> #else
</span><span class="cx">     UNUSED_PARAM(vPC);
</span><span class="lines">@@ -415,7 +415,7 @@
</span><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><span class="cx">     X86Assembler::JmpSrc call = m_jit.emitCall();
</span><span class="cx">     m_calls.append(CallRecord(call, helper, bytecodeIndex));
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     m_jit.movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, false), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="cx"> #endif
</span><span class="cx">     killLastResultRegister();
</span><span class="lines">@@ -425,7 +425,7 @@
</span><span class="cx"> 
</span><span class="cx"> ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_p helper)
</span><span class="cx"> {
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     m_jit.movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, true), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="cx"> #else
</span><span class="cx">     UNUSED_PARAM(vPC);
</span><span class="lines">@@ -434,7 +434,7 @@
</span><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><span class="cx">     X86Assembler::JmpSrc call = m_jit.emitCall();
</span><span class="cx">     m_calls.append(CallRecord(call, helper, bytecodeIndex));
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     m_jit.movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, false), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="cx"> #endif
</span><span class="cx">     killLastResultRegister();
</span><span class="lines">@@ -444,7 +444,7 @@
</span><span class="cx"> 
</span><span class="cx"> ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_b helper)
</span><span class="cx"> {
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     m_jit.movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, true), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="cx"> #else
</span><span class="cx">     UNUSED_PARAM(vPC);
</span><span class="lines">@@ -453,7 +453,7 @@
</span><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><span class="cx">     X86Assembler::JmpSrc call = m_jit.emitCall();
</span><span class="cx">     m_calls.append(CallRecord(call, helper, bytecodeIndex));
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     m_jit.movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, false), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="cx"> #endif
</span><span class="cx">     killLastResultRegister();
</span><span class="lines">@@ -463,7 +463,7 @@
</span><span class="cx"> 
</span><span class="cx"> ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_v helper)
</span><span class="cx"> {
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     m_jit.movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, true), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="cx"> #else
</span><span class="cx">     UNUSED_PARAM(vPC);
</span><span class="lines">@@ -472,7 +472,7 @@
</span><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><span class="cx">     X86Assembler::JmpSrc call = m_jit.emitCall();
</span><span class="cx">     m_calls.append(CallRecord(call, helper, bytecodeIndex));
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     m_jit.movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, false), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="cx"> #endif
</span><span class="cx">     killLastResultRegister();
</span><span class="lines">@@ -482,7 +482,7 @@
</span><span class="cx"> 
</span><span class="cx"> ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_s helper)
</span><span class="cx"> {
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     m_jit.movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, true), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="cx"> #else
</span><span class="cx">     UNUSED_PARAM(vPC);
</span><span class="lines">@@ -491,7 +491,7 @@
</span><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><span class="cx">     X86Assembler::JmpSrc call = m_jit.emitCall();
</span><span class="cx">     m_calls.append(CallRecord(call, helper, bytecodeIndex));
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     m_jit.movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, false), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="cx"> #endif
</span><span class="cx">     killLastResultRegister();
</span><span class="lines">@@ -501,7 +501,7 @@
</span><span class="cx"> 
</span><span class="cx"> ALWAYS_INLINE X86Assembler::JmpSrc CTI::emitCTICall(Instruction* vPC, unsigned bytecodeIndex, CTIHelper_2 helper)
</span><span class="cx"> {
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     m_jit.movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, true), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="cx"> #else
</span><span class="cx">     UNUSED_PARAM(vPC);
</span><span class="lines">@@ -510,7 +510,7 @@
</span><span class="cx">     emitPutCTIParam(X86::edi, CTI_ARGS_callFrame);
</span><span class="cx">     X86Assembler::JmpSrc call = m_jit.emitCall();
</span><span class="cx">     m_calls.append(CallRecord(call, helper, bytecodeIndex));
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     m_jit.movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(vPC, false), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="cx"> #endif
</span><span class="cx">     killLastResultRegister();
</span><span class="lines">@@ -702,7 +702,7 @@
</span><span class="cx">     emitPutCTIArgConstant(reinterpret_cast&lt;unsigned&gt;(instruction), 20);
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-void CTI::compileOpCall(BytecodeID bytecodeID, Instruction* instruction, unsigned i, unsigned callLinkInfoIndex)
</del><ins>+void CTI::compileOpCall(OpcodeID opcodeID, Instruction* instruction, unsigned i, unsigned callLinkInfoIndex)
</ins><span class="cx"> {
</span><span class="cx">     int dst = instruction[1].u.operand;
</span><span class="cx">     int callee = instruction[2].u.operand;
</span><span class="lines">@@ -711,7 +711,7 @@
</span><span class="cx"> 
</span><span class="cx">     // Handle eval
</span><span class="cx">     X86Assembler::JmpSrc wasEval;
</span><del>-    if (bytecodeID == op_call_eval) {
</del><ins>+    if (opcodeID == op_call_eval) {
</ins><span class="cx">         emitGetVirtualRegister(callee, X86::ecx, i);
</span><span class="cx">         compileOpCallEvalSetupArgs(instruction);
</span><span class="cx"> 
</span><span class="lines">@@ -732,7 +732,7 @@
</span><span class="cx">     // The following is the fast case, only used whan a callee can be linked.
</span><span class="cx"> 
</span><span class="cx">     // In the case of OpConstruct, call out to a cti_ function to create the new object.
</span><del>-    if (bytecodeID == op_construct) {
</del><ins>+    if (opcodeID == op_construct) {
</ins><span class="cx">         int proto = instruction[5].u.operand;
</span><span class="cx">         int thisRegister = instruction[6].u.operand;
</span><span class="cx"> 
</span><span class="lines">@@ -756,7 +756,7 @@
</span><span class="cx">     // Call to the callee
</span><span class="cx">     m_callStructureStubCompilationInfo[callLinkInfoIndex].hotPathOther = emitNakedCall(i, reinterpret_cast&lt;void*&gt;(unreachable));
</span><span class="cx">     
</span><del>-    if (bytecodeID == op_call_eval)
</del><ins>+    if (opcodeID == op_call_eval)
</ins><span class="cx">         m_jit.link(wasEval, m_jit.label());
</span><span class="cx"> 
</span><span class="cx">     // Put the return value in dst. In the interpreter, op_ret does this.
</span><span class="lines">@@ -878,7 +878,7 @@
</span><span class="cx">     emitPutVirtualRegister(dst);
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-void CTI::compileBinaryArithOp(BytecodeID bytecodeID, unsigned dst, unsigned src1, unsigned src2, OperandTypes types, unsigned i)
</del><ins>+void CTI::compileBinaryArithOp(OpcodeID opcodeID, unsigned dst, unsigned src1, unsigned src2, OperandTypes types, unsigned i)
</ins><span class="cx"> {
</span><span class="cx">     StructureID* numberStructureID = m_globalData-&gt;numberStructureID.get();
</span><span class="cx">     X86Assembler::JmpSrc wasJSNumberCell1;
</span><span class="lines">@@ -919,12 +919,12 @@
</span><span class="cx">         m_jit.cvtsi2sd_rr(X86::eax, X86::xmm0);
</span><span class="cx">         // (1c) 
</span><span class="cx">         m_jit.link(loadedDouble, m_jit.label());
</span><del>-        if (bytecodeID == op_add)
</del><ins>+        if (opcodeID == op_add)
</ins><span class="cx">             m_jit.addsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm0);
</span><del>-        else if (bytecodeID == op_sub)
</del><ins>+        else if (opcodeID == op_sub)
</ins><span class="cx">             m_jit.subsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm0);
</span><span class="cx">         else {
</span><del>-            ASSERT(bytecodeID == op_mul);
</del><ins>+            ASSERT(opcodeID == op_mul);
</ins><span class="cx">             m_jit.mulsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::edx, X86::xmm0);
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="lines">@@ -967,12 +967,12 @@
</span><span class="cx">         // (1c) 
</span><span class="cx">         m_jit.link(loadedDouble, m_jit.label());
</span><span class="cx">         m_jit.movsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
</span><del>-        if (bytecodeID == op_add)
</del><ins>+        if (opcodeID == op_add)
</ins><span class="cx">             m_jit.addsd_rr(X86::xmm1, X86::xmm0);
</span><del>-        else if (bytecodeID == op_sub)
</del><ins>+        else if (opcodeID == op_sub)
</ins><span class="cx">             m_jit.subsd_rr(X86::xmm1, X86::xmm0);
</span><span class="cx">         else {
</span><del>-            ASSERT(bytecodeID == op_mul);
</del><ins>+            ASSERT(opcodeID == op_mul);
</ins><span class="cx">             m_jit.mulsd_rr(X86::xmm1, X86::xmm0);
</span><span class="cx">         }
</span><span class="cx">         m_jit.movsd_rm(X86::xmm0, OBJECT_OFFSET(JSNumberCell, m_value), X86::eax);
</span><span class="lines">@@ -988,16 +988,16 @@
</span><span class="cx">     } else
</span><span class="cx">         emitJumpSlowCaseIfNotImmNums(X86::eax, X86::edx, i);
</span><span class="cx"> 
</span><del>-    if (bytecodeID == op_add) {
</del><ins>+    if (opcodeID == op_add) {
</ins><span class="cx">         emitFastArithDeTagImmediate(X86::eax);
</span><span class="cx">         m_jit.addl_rr(X86::edx, X86::eax);
</span><span class="cx">         m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJo(), i));
</span><del>-    } else  if (bytecodeID == op_sub) {
</del><ins>+    } else  if (opcodeID == op_sub) {
</ins><span class="cx">         m_jit.subl_rr(X86::edx, X86::eax);
</span><span class="cx">         m_slowCases.append(SlowCaseEntry(m_jit.emitUnlinkedJo(), i));
</span><span class="cx">         emitFastArithReTagImmediate(X86::eax);
</span><span class="cx">     } else {
</span><del>-        ASSERT(bytecodeID == op_mul);
</del><ins>+        ASSERT(opcodeID == op_mul);
</ins><span class="cx">         // convert eax &amp; edx from JSImmediates to ints, and check if either are zero
</span><span class="cx">         emitFastArithImmToInt(X86::edx);
</span><span class="cx">         X86Assembler::JmpSrc op1Zero = emitFastArithDeTagImmediateJumpIfZero(X86::eax);
</span><span class="lines">@@ -1027,7 +1027,7 @@
</span><span class="cx">     }
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-void CTI::compileBinaryArithOpSlowCase(Instruction* vPC, BytecodeID bytecodeID, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter, unsigned dst, unsigned src1, unsigned src2, OperandTypes types, unsigned i)
</del><ins>+void CTI::compileBinaryArithOpSlowCase(Instruction* vPC, OpcodeID opcodeID, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter, unsigned dst, unsigned src1, unsigned src2, OperandTypes types, unsigned i)
</ins><span class="cx"> {
</span><span class="cx">     X86Assembler::JmpDst here = m_jit.label();
</span><span class="cx">     m_jit.link(iter-&gt;from, here);
</span><span class="lines">@@ -1059,17 +1059,17 @@
</span><span class="cx">         m_jit.link((++iter)-&gt;from, here);
</span><span class="cx"> 
</span><span class="cx">     // additional entry point to handle -0 cases.
</span><del>-    if (bytecodeID == op_mul)
</del><ins>+    if (opcodeID == op_mul)
</ins><span class="cx">         m_jit.link((++iter)-&gt;from, here);
</span><span class="cx"> 
</span><span class="cx">     emitPutCTIArgFromVirtualRegister(src1, 0, X86::ecx);
</span><span class="cx">     emitPutCTIArgFromVirtualRegister(src2, 4, X86::ecx);
</span><del>-    if (bytecodeID == op_add)
</del><ins>+    if (opcodeID == op_add)
</ins><span class="cx">         emitCTICall(vPC, i, BytecodeInterpreter::cti_op_add);
</span><del>-    else if (bytecodeID == op_sub)
</del><ins>+    else if (opcodeID == op_sub)
</ins><span class="cx">         emitCTICall(vPC, i, BytecodeInterpreter::cti_op_sub);
</span><span class="cx">     else {
</span><del>-        ASSERT(bytecodeID == op_mul);
</del><ins>+        ASSERT(opcodeID == op_mul);
</ins><span class="cx">         emitCTICall(vPC, i, BytecodeInterpreter::cti_op_mul);
</span><span class="cx">     }
</span><span class="cx">     emitPutVirtualRegister(dst);
</span><span class="lines">@@ -1084,16 +1084,16 @@
</span><span class="cx">     unsigned callLinkInfoIndex = 0;
</span><span class="cx"> 
</span><span class="cx">     for (unsigned i = 0; i &lt; instructionCount; ) {
</span><del>-        ASSERT_WITH_MESSAGE(m_interpreter-&gt;isBytecode(instruction[i].u.bytecode), &quot;privateCompileMainPass gone bad @ %d&quot;, i);
</del><ins>+        ASSERT_WITH_MESSAGE(m_interpreter-&gt;isOpcode(instruction[i].u.opcode), &quot;privateCompileMainPass gone bad @ %d&quot;, i);
</ins><span class="cx"> 
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">         if (i &gt; 0) // Avoid the overhead of sampling op_enter twice.
</span><span class="cx">             m_jit.movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(instruction + i), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="cx"> #endif
</span><span class="cx"> 
</span><span class="cx">         m_labels[i] = m_jit.label();
</span><del>-        BytecodeID bytecodeID = m_interpreter-&gt;getBytecodeID(instruction[i].u.bytecode);
-        switch (bytecodeID) {
</del><ins>+        OpcodeID opcodeID = m_interpreter-&gt;getOpcodeID(instruction[i].u.opcode);
+        switch (opcodeID) {
</ins><span class="cx">         case op_mov: {
</span><span class="cx">             unsigned src = instruction[i + 2].u.operand;
</span><span class="cx">             if (m_codeBlock-&gt;isConstantRegisterIndex(src))
</span><span class="lines">@@ -1387,8 +1387,8 @@
</span><span class="cx">         case op_call:
</span><span class="cx">         case op_call_eval:
</span><span class="cx">         case op_construct: {
</span><del>-            compileOpCall(bytecodeID, instruction + i, i, callLinkInfoIndex++);
-            i += (bytecodeID == op_construct ? 7 : 5);
</del><ins>+            compileOpCall(opcodeID, instruction + i, i, callLinkInfoIndex++);
+            i += (opcodeID == op_construct ? 7 : 5);
</ins><span class="cx">             break;
</span><span class="cx">         }
</span><span class="cx">         case op_get_global_var: {
</span><span class="lines">@@ -2399,7 +2399,7 @@
</span><span class="cx">         unsigned firstTo = i;
</span><span class="cx"> #endif
</span><span class="cx"> 
</span><del>-        switch (BytecodeID bytecodeID = m_interpreter-&gt;getBytecodeID(instruction[i].u.bytecode)) {
</del><ins>+        switch (OpcodeID opcodeID = m_interpreter-&gt;getOpcodeID(instruction[i].u.opcode)) {
</ins><span class="cx">         case op_convert_this: {
</span><span class="cx">             m_jit.link(iter-&gt;from, m_jit.label());
</span><span class="cx">             m_jit.link((++iter)-&gt;from, m_jit.label());
</span><span class="lines">@@ -2889,9 +2889,9 @@
</span><span class="cx">             m_jit.link(iter-&gt;from, m_jit.label());
</span><span class="cx"> 
</span><span class="cx">             // The arguments have been set up on the hot path for op_call_eval
</span><del>-            if (bytecodeID == op_call)
</del><ins>+            if (opcodeID == op_call)
</ins><span class="cx">                 compileOpCallSetupArgs(instruction + i);
</span><del>-            else if (bytecodeID == op_construct)
</del><ins>+            else if (opcodeID == op_construct)
</ins><span class="cx">                 compileOpConstructSetupArgs(instruction + i);
</span><span class="cx"> 
</span><span class="cx">             // Fast check for JS function.
</span><span class="lines">@@ -2901,7 +2901,7 @@
</span><span class="cx">             X86Assembler::JmpSrc callLinkFailNotJSFunction = m_jit.emitUnlinkedJne();
</span><span class="cx"> 
</span><span class="cx">             // First, in the case of a construct, allocate the new object.
</span><del>-            if (bytecodeID == op_construct) {
</del><ins>+            if (opcodeID == op_construct) {
</ins><span class="cx">                 emitCTICall(instruction, i, BytecodeInterpreter::cti_op_construct_JSConstruct);
</span><span class="cx">                 emitPutVirtualRegister(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
</span><span class="cx">                 emitGetVirtualRegister(callee, X86::ecx, i);
</span><span class="lines">@@ -2922,9 +2922,9 @@
</span><span class="cx">             m_callStructureStubCompilationInfo[callLinkInfoIndex].coldPathOther = m_jit.label();
</span><span class="cx"> 
</span><span class="cx">             // The arguments have been set up on the hot path for op_call_eval
</span><del>-            if (bytecodeID == op_call)
</del><ins>+            if (opcodeID == op_call)
</ins><span class="cx">                 compileOpCallSetupArgs(instruction + i);
</span><del>-            else if (bytecodeID == op_construct)
</del><ins>+            else if (opcodeID == op_construct)
</ins><span class="cx">                 compileOpConstructSetupArgs(instruction + i);
</span><span class="cx"> 
</span><span class="cx">             // Check for JSFunctions.
</span><span class="lines">@@ -2938,14 +2938,14 @@
</span><span class="cx">             m_jit.link(isNotObject, notJSFunctionlabel);
</span><span class="cx">             m_jit.link(callLinkFailNotObject, notJSFunctionlabel);
</span><span class="cx">             m_jit.link(callLinkFailNotJSFunction, notJSFunctionlabel);
</span><del>-            emitCTICall(instruction + i, i, ((bytecodeID == op_construct) ? BytecodeInterpreter::cti_op_construct_NotJSConstruct : BytecodeInterpreter::cti_op_call_NotJSFunction));
</del><ins>+            emitCTICall(instruction + i, i, ((opcodeID == op_construct) ? BytecodeInterpreter::cti_op_construct_NotJSConstruct : BytecodeInterpreter::cti_op_call_NotJSFunction));
</ins><span class="cx">             X86Assembler::JmpSrc wasNotJSFunction = m_jit.emitUnlinkedJmp();
</span><span class="cx"> 
</span><span class="cx">             // Next, handle JSFunctions...
</span><span class="cx">             m_jit.link(isJSFunction, m_jit.label());
</span><span class="cx"> 
</span><span class="cx">             // First, in the case of a construct, allocate the new object.
</span><del>-            if (bytecodeID == op_construct) {
</del><ins>+            if (opcodeID == op_construct) {
</ins><span class="cx">                 emitCTICall(instruction, i, BytecodeInterpreter::cti_op_construct_JSConstruct);
</span><span class="cx">                 emitPutVirtualRegister(registerOffset - RegisterFile::CallFrameHeaderSize - argCount);
</span><span class="cx">                 emitGetVirtualRegister(callee, X86::ecx, i);
</span><span class="lines">@@ -2969,7 +2969,7 @@
</span><span class="cx"> #endif
</span><span class="cx">             ++callLinkInfoIndex;
</span><span class="cx"> 
</span><del>-            i += (bytecodeID == op_construct ? 7 : 5);
</del><ins>+            i += (opcodeID == op_construct ? 7 : 5);
</ins><span class="cx">             break;
</span><span class="cx">         }
</span><span class="cx">         case op_to_jsnumber: {
</span><span class="lines">@@ -3005,7 +3005,7 @@
</span><span class="cx"> #if ENABLE(CODEBLOCK_SAMPLING)
</span><span class="cx">         m_jit.movl_i32m(reinterpret_cast&lt;unsigned&gt;(m_codeBlock), m_interpreter-&gt;sampler()-&gt;codeBlockSlot());
</span><span class="cx"> #endif
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">         m_jit.movl_i32m(m_interpreter-&gt;sampler()-&gt;encodeSample(m_codeBlock-&gt;instructions.begin()), m_interpreter-&gt;sampler()-&gt;sampleSlot());
</span><span class="cx"> #endif
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkJavaScriptCoreVMCTIh"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/VM/CTI.h (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/VM/CTI.h        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/VM/CTI.h        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -275,7 +275,7 @@
</span><span class="cx">         static const int repatchOffsetGetByIdStructureID = 7;
</span><span class="cx">         static const int repatchOffsetGetByIdBranchToSlowCase = 13;
</span><span class="cx">         static const int repatchOffsetGetByIdPropertyMapOffset = 22;
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">         static const int repatchOffsetGetByIdSlowCaseCall = 27 + 4 + ctiArgumentInitSize;
</span><span class="cx"> #else
</span><span class="cx">         static const int repatchOffsetGetByIdSlowCaseCall = 17 + 4 + ctiArgumentInitSize;
</span><span class="lines">@@ -363,7 +363,7 @@
</span><span class="cx">         void privateCompileCTIMachineTrampolines();
</span><span class="cx">         void privateCompilePatchGetArrayLength(void* returnAddress);
</span><span class="cx"> 
</span><del>-        void compileOpCall(BytecodeID, Instruction* instruction, unsigned i, unsigned callLinkInfoIndex);
</del><ins>+        void compileOpCall(OpcodeID, Instruction* instruction, unsigned i, unsigned callLinkInfoIndex);
</ins><span class="cx">         void compileOpCallInitializeCallFrame();
</span><span class="cx">         void compileOpCallSetupArgs(Instruction*);
</span><span class="cx">         void compileOpCallEvalSetupArgs(Instruction*);
</span><span class="lines">@@ -371,8 +371,8 @@
</span><span class="cx">         enum CompileOpStrictEqType { OpStrictEq, OpNStrictEq };
</span><span class="cx">         void compileOpStrictEq(Instruction* instruction, unsigned i, CompileOpStrictEqType type);
</span><span class="cx">         void putDoubleResultToJSNumberCellOrJSImmediate(X86::XMMRegisterID xmmSource, X86::RegisterID jsNumberCell, unsigned dst, X86Assembler::JmpSrc* wroteJSNumberCell,  X86::XMMRegisterID tempXmm, X86::RegisterID tempReg1, X86::RegisterID tempReg2);
</span><del>-        void compileBinaryArithOp(BytecodeID, unsigned dst, unsigned src1, unsigned src2, OperandTypes opi, unsigned i);
-        void compileBinaryArithOpSlowCase(Instruction*, BytecodeID, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter, unsigned dst, unsigned src1, unsigned src2, OperandTypes opi, unsigned i);
</del><ins>+        void compileBinaryArithOp(OpcodeID, unsigned dst, unsigned src1, unsigned src2, OperandTypes opi, unsigned i);
+        void compileBinaryArithOpSlowCase(Instruction*, OpcodeID, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter, unsigned dst, unsigned src1, unsigned src2, OperandTypes opi, unsigned i);
</ins><span class="cx"> 
</span><span class="cx">         void emitGetVirtualRegister(int src, X86Assembler::RegisterID dst, unsigned i);
</span><span class="cx">         void emitGetVirtualRegisters(int src1, X86Assembler::RegisterID dst1, int src2, X86Assembler::RegisterID dst2, unsigned i);
</span></span></pre></div>
<a id="trunkJavaScriptCoreVMCodeBlockcpp"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/VM/CodeBlock.cpp (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/VM/CodeBlock.cpp        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/VM/CodeBlock.cpp        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -39,7 +39,7 @@
</span><span class="cx"> 
</span><span class="cx"> namespace JSC {
</span><span class="cx"> 
</span><del>-#if !defined(NDEBUG) || ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if !defined(NDEBUG) || ENABLE(OPCODE_SAMPLING)
</ins><span class="cx"> 
</span><span class="cx"> static UString escapeQuotes(const UString&amp; str)
</span><span class="cx"> {
</span><span class="lines">@@ -184,41 +184,41 @@
</span><span class="cx">     BytecodeInterpreter* interpreter = globalData-&gt;interpreter;
</span><span class="cx">     unsigned instructionOffset = vPC - instructions.begin();
</span><span class="cx"> 
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_by_id)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_by_id)) {
</ins><span class="cx">         printStructureID(&quot;get_by_id&quot;, vPC, 4);
</span><span class="cx">         return;
</span><span class="cx">     }
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_by_id_self)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_by_id_self)) {
</ins><span class="cx">         printStructureID(&quot;get_by_id_self&quot;, vPC, 4);
</span><span class="cx">         return;
</span><span class="cx">     }
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_by_id_proto)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_by_id_proto)) {
</ins><span class="cx">         printf(&quot;  [%4d] %s: %s, %s\n&quot;, instructionOffset, &quot;get_by_id_proto&quot;, pointerToSourceString(vPC[4].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structureID).UTF8String().c_str());
</span><span class="cx">         return;
</span><span class="cx">     }
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_put_by_id_transition)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_put_by_id_transition)) {
</ins><span class="cx">         printf(&quot;  [%4d] %s: %s, %s, %s\n&quot;, instructionOffset, &quot;put_by_id_new&quot;, pointerToSourceString(vPC[4].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[6].u.structureIDChain).UTF8String().c_str());
</span><span class="cx">         return;
</span><span class="cx">     }
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_by_id_chain)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_by_id_chain)) {
</ins><span class="cx">         printf(&quot;  [%4d] %s: %s, %s\n&quot;, instructionOffset, &quot;get_by_id_chain&quot;, pointerToSourceString(vPC[4].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structureIDChain).UTF8String().c_str());
</span><span class="cx">         return;
</span><span class="cx">     }
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_put_by_id)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_put_by_id)) {
</ins><span class="cx">         printStructureID(&quot;put_by_id&quot;, vPC, 4);
</span><span class="cx">         return;
</span><span class="cx">     }
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_put_by_id_replace)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_put_by_id_replace)) {
</ins><span class="cx">         printStructureID(&quot;put_by_id_replace&quot;, vPC, 4);
</span><span class="cx">         return;
</span><span class="cx">     }
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_resolve_global)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_resolve_global)) {
</ins><span class="cx">         printStructureID(&quot;resolve_global&quot;, vPC, 4);
</span><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     // These instructions doesn't ref StructureIDs.
</span><del>-    ASSERT(vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_by_id_generic) || vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_put_by_id_generic) || vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_call) || vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_call_eval) || vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_construct));
</del><ins>+    ASSERT(vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == interpreter-&gt;getOpcode(op_put_by_id_generic) || vPC[0].u.opcode == interpreter-&gt;getOpcode(op_call) || vPC[0].u.opcode == interpreter-&gt;getOpcode(op_call_eval) || vPC[0].u.opcode == interpreter-&gt;getOpcode(op_construct));
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void CodeBlock::dump(ExecState* exec) const
</span><span class="lines">@@ -228,7 +228,7 @@
</span><span class="cx"> 
</span><span class="cx">     size_t instructionCount = 0;
</span><span class="cx">     for (Vector&lt;Instruction&gt;::const_iterator it = begin; it != end; ++it)
</span><del>-        if (exec-&gt;interpreter()-&gt;isBytecode(it-&gt;u.bytecode))
</del><ins>+        if (exec-&gt;interpreter()-&gt;isOpcode(it-&gt;u.opcode))
</ins><span class="cx">             ++instructionCount;
</span><span class="cx"> 
</span><span class="cx">     printf(&quot;%lu instructions; %lu bytes at %p; %d parameter(s); %d callee register(s)\n\n&quot;,
</span><span class="lines">@@ -359,7 +359,7 @@
</span><span class="cx"> void CodeBlock::dump(ExecState* exec, const Vector&lt;Instruction&gt;::const_iterator&amp; begin, Vector&lt;Instruction&gt;::const_iterator&amp; it) const
</span><span class="cx"> {
</span><span class="cx">     int location = it - begin;
</span><del>-    switch (exec-&gt;interpreter()-&gt;getBytecodeID(it-&gt;u.bytecode)) {
</del><ins>+    switch (exec-&gt;interpreter()-&gt;getOpcodeID(it-&gt;u.opcode)) {
</ins><span class="cx">         case op_enter: {
</span><span class="cx">             printf(&quot;[%4d] enter\n&quot;, location);
</span><span class="cx">             break;
</span><span class="lines">@@ -945,7 +945,7 @@
</span><span class="cx">     }
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-#endif // !defined(NDEBUG) || ENABLE(BYTECODE_SAMPLING)
</del><ins>+#endif // !defined(NDEBUG) || ENABLE(OPCODE_SAMPLING)
</ins><span class="cx"> 
</span><span class="cx"> CodeBlock::~CodeBlock()
</span><span class="cx"> {
</span><span class="lines">@@ -990,71 +990,71 @@
</span><span class="cx"> {
</span><span class="cx">     BytecodeInterpreter* interpreter = globalData-&gt;interpreter;
</span><span class="cx"> 
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_by_id_self)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_by_id_self)) {
</ins><span class="cx">         vPC[4].u.structureID-&gt;deref();
</span><span class="cx">         return;
</span><span class="cx">     }
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_by_id_proto)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_by_id_proto)) {
</ins><span class="cx">         vPC[4].u.structureID-&gt;deref();
</span><span class="cx">         vPC[5].u.structureID-&gt;deref();
</span><span class="cx">         return;
</span><span class="cx">     }
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_by_id_chain)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_by_id_chain)) {
</ins><span class="cx">         vPC[4].u.structureID-&gt;deref();
</span><span class="cx">         vPC[5].u.structureIDChain-&gt;deref();
</span><span class="cx">         return;
</span><span class="cx">     }
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_put_by_id_transition)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_put_by_id_transition)) {
</ins><span class="cx">         vPC[4].u.structureID-&gt;deref();
</span><span class="cx">         vPC[5].u.structureID-&gt;deref();
</span><span class="cx">         vPC[6].u.structureIDChain-&gt;deref();
</span><span class="cx">         return;
</span><span class="cx">     }
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_put_by_id_replace)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_put_by_id_replace)) {
</ins><span class="cx">         vPC[4].u.structureID-&gt;deref();
</span><span class="cx">         return;
</span><span class="cx">     }
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_resolve_global)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_resolve_global)) {
</ins><span class="cx">         if(vPC[4].u.structureID)
</span><span class="cx">             vPC[4].u.structureID-&gt;deref();
</span><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx">     
</span><span class="cx">     // These instructions don't ref their StructureIDs.
</span><del>-    ASSERT(vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_by_id) || vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_put_by_id) || vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_by_id_generic) || vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_put_by_id_generic) || vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_array_length) || vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_string_length));
</del><ins>+    ASSERT(vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_by_id) || vPC[0].u.opcode == interpreter-&gt;getOpcode(op_put_by_id) || vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == interpreter-&gt;getOpcode(op_put_by_id_generic) || vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_array_length) || vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_string_length));
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void CodeBlock::refStructureIDs(Instruction* vPC) const
</span><span class="cx"> {
</span><span class="cx">     BytecodeInterpreter* interpreter = globalData-&gt;interpreter;
</span><span class="cx"> 
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_by_id_self)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_by_id_self)) {
</ins><span class="cx">         vPC[4].u.structureID-&gt;ref();
</span><span class="cx">         return;
</span><span class="cx">     }
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_by_id_proto)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_by_id_proto)) {
</ins><span class="cx">         vPC[4].u.structureID-&gt;ref();
</span><span class="cx">         vPC[5].u.structureID-&gt;ref();
</span><span class="cx">         return;
</span><span class="cx">     }
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_by_id_chain)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_by_id_chain)) {
</ins><span class="cx">         vPC[4].u.structureID-&gt;ref();
</span><span class="cx">         vPC[5].u.structureIDChain-&gt;ref();
</span><span class="cx">         return;
</span><span class="cx">     }
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_put_by_id_transition)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_put_by_id_transition)) {
</ins><span class="cx">         vPC[4].u.structureID-&gt;ref();
</span><span class="cx">         vPC[5].u.structureID-&gt;ref();
</span><span class="cx">         vPC[6].u.structureIDChain-&gt;ref();
</span><span class="cx">         return;
</span><span class="cx">     }
</span><del>-    if (vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_put_by_id_replace)) {
</del><ins>+    if (vPC[0].u.opcode == interpreter-&gt;getOpcode(op_put_by_id_replace)) {
</ins><span class="cx">         vPC[4].u.structureID-&gt;ref();
</span><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx">     
</span><span class="cx">     // These instructions don't ref their StructureIDs.
</span><del>-    ASSERT(vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_by_id) || vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_put_by_id) || vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_get_by_id_generic) || vPC[0].u.bytecode == interpreter-&gt;getBytecode(op_put_by_id_generic));
</del><ins>+    ASSERT(vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_by_id) || vPC[0].u.opcode == interpreter-&gt;getOpcode(op_put_by_id) || vPC[0].u.opcode == interpreter-&gt;getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == interpreter-&gt;getOpcode(op_put_by_id_generic));
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void CodeBlock::mark()
</span></span></pre></div>
<a id="trunkJavaScriptCoreVMCodeBlockh"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/VM/CodeBlock.h (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/VM/CodeBlock.h        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/VM/CodeBlock.h        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -286,7 +286,7 @@
</span><span class="cx">             return index &gt;= numVars + numConstants;
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-#if !defined(NDEBUG) || ENABLE_BYTECODE_SAMPLING
</del><ins>+#if !defined(NDEBUG) || ENABLE_OPCODE_SAMPLING
</ins><span class="cx">         void dump(ExecState*) const;
</span><span class="cx">         void printStructureIDs(const Instruction*) const;
</span><span class="cx">         void printStructureID(const char* name, const Instruction*, int operand) const;
</span><span class="lines">@@ -364,7 +364,7 @@
</span><span class="cx"> 
</span><span class="cx">         SymbolTable symbolTable;
</span><span class="cx">     private:
</span><del>-#if !defined(NDEBUG) || ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if !defined(NDEBUG) || ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">         void dump(ExecState*, const Vector&lt;Instruction&gt;::const_iterator&amp; begin, Vector&lt;Instruction&gt;::const_iterator&amp;) const;
</span><span class="cx"> #endif
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkJavaScriptCoreVMExceptionHelperscpp"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/VM/ExceptionHelpers.cpp (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/VM/ExceptionHelpers.cpp        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/VM/ExceptionHelpers.cpp        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -208,9 +208,9 @@
</span><span class="cx"> 
</span><span class="cx"> JSObject* createNotAnObjectError(ExecState* exec, JSNotAnObjectErrorStub* error, const Instruction* vPC, CodeBlock* codeBlock)
</span><span class="cx"> {
</span><del>-    if (vPC[8].u.bytecode == exec-&gt;interpreter()-&gt;getBytecode(op_instanceof))
</del><ins>+    if (vPC[8].u.opcode == exec-&gt;interpreter()-&gt;getOpcode(op_instanceof))
</ins><span class="cx">         return createInvalidParamError(exec, &quot;instanceof&quot;, error-&gt;isNull() ? jsNull() : jsUndefined(), vPC, codeBlock);
</span><del>-    if (vPC[8].u.bytecode == exec-&gt;interpreter()-&gt;getBytecode(op_construct))
</del><ins>+    if (vPC[8].u.opcode == exec-&gt;interpreter()-&gt;getOpcode(op_construct))
</ins><span class="cx">         return createNotAConstructorError(exec, error-&gt;isNull() ? jsNull() : jsUndefined(), vPC, codeBlock);
</span><span class="cx"> 
</span><span class="cx">     int startOffset = 0;
</span></span></pre></div>
<a id="trunkJavaScriptCoreVMInstructionh"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/VM/Instruction.h (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/VM/Instruction.h        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/VM/Instruction.h        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -40,7 +40,7 @@
</span><span class="cx">     class StructureIDChain;
</span><span class="cx"> 
</span><span class="cx">     struct Instruction {
</span><del>-        Instruction(Bytecode bytecode) { u.bytecode = bytecode; }
</del><ins>+        Instruction(Opcode opcode) { u.opcode = opcode; }
</ins><span class="cx">         Instruction(int operand)
</span><span class="cx">         {
</span><span class="cx">             // We have to initialize one of the pointer members to ensure that
</span><span class="lines">@@ -54,7 +54,7 @@
</span><span class="cx">         Instruction(JSCell* jsCell) { u.jsCell = jsCell; }
</span><span class="cx"> 
</span><span class="cx">         union {
</span><del>-            Bytecode bytecode;
</del><ins>+            Opcode opcode;
</ins><span class="cx">             int operand;
</span><span class="cx">             StructureID* structureID;
</span><span class="cx">             StructureIDChain* structureIDChain;
</span></span></pre></div>
<a id="trunkJavaScriptCoreVMMachinecpp"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/VM/Machine.cpp (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/VM/Machine.cpp        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/VM/Machine.cpp        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -743,14 +743,14 @@
</span><span class="cx"> 
</span><span class="cx"> #endif
</span><span class="cx"> 
</span><del>-bool BytecodeInterpreter::isBytecode(Bytecode bytecode)
</del><ins>+bool BytecodeInterpreter::isOpcode(Opcode opcode)
</ins><span class="cx"> {
</span><span class="cx"> #if HAVE(COMPUTED_GOTO)
</span><del>-    return bytecode != HashTraits&lt;Bytecode&gt;::emptyValue()
-        &amp;&amp; !HashTraits&lt;Bytecode&gt;::isDeletedValue(bytecode)
-        &amp;&amp; m_bytecodeIDTable.contains(bytecode);
</del><ins>+    return opcode != HashTraits&lt;Opcode&gt;::emptyValue()
+        &amp;&amp; !HashTraits&lt;Opcode&gt;::isDeletedValue(opcode)
+        &amp;&amp; m_opcodeIDTable.contains(opcode);
</ins><span class="cx"> #else
</span><del>-    return bytecode &gt;= 0 &amp;&amp; bytecode &lt;= op_end;
</del><ins>+    return opcode &gt;= 0 &amp;&amp; opcode &lt;= op_end;
</ins><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="lines">@@ -849,9 +849,9 @@
</span><span class="cx">     // the profiler manually that the call instruction has returned, since
</span><span class="cx">     // we'll never reach the relevant op_profile_did_call.
</span><span class="cx">     if (Profiler* profiler = *Profiler::enabledProfilerReference()) {
</span><del>-        if (isCallBytecode(vPC[0].u.bytecode))
</del><ins>+        if (isCallBytecode(vPC[0].u.opcode))
</ins><span class="cx">             profiler-&gt;didExecute(callFrame, callFrame[vPC[2].u.operand].jsValue(callFrame));
</span><del>-        else if (vPC[8].u.bytecode == getBytecode(op_construct))
</del><ins>+        else if (vPC[8].u.opcode == getOpcode(op_construct))
</ins><span class="cx">             profiler-&gt;didExecute(callFrame, callFrame[vPC[10].u.operand].jsValue(callFrame));
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -1249,7 +1249,7 @@
</span><span class="cx"> NEVER_INLINE void BytecodeInterpreter::tryCachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const PutPropertySlot&amp; slot)
</span><span class="cx"> {
</span><span class="cx">     // Recursive invocation may already have specialized this instruction.
</span><del>-    if (vPC[0].u.bytecode != getBytecode(op_put_by_id))
</del><ins>+    if (vPC[0].u.opcode != getOpcode(op_put_by_id))
</ins><span class="cx">         return;
</span><span class="cx"> 
</span><span class="cx">     if (JSImmediate::isImmediate(baseValue))
</span><span class="lines">@@ -1257,7 +1257,7 @@
</span><span class="cx"> 
</span><span class="cx">     // Uncacheable: give up.
</span><span class="cx">     if (!slot.isCacheable()) {
</span><del>-        vPC[0] = getBytecode(op_put_by_id_generic);
</del><ins>+        vPC[0] = getOpcode(op_put_by_id_generic);
</ins><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx">     
</span><span class="lines">@@ -1265,7 +1265,7 @@
</span><span class="cx">     StructureID* structureID = baseCell-&gt;structureID();
</span><span class="cx"> 
</span><span class="cx">     if (structureID-&gt;isDictionary()) {
</span><del>-        vPC[0] = getBytecode(op_put_by_id_generic);
</del><ins>+        vPC[0] = getOpcode(op_put_by_id_generic);
</ins><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -1279,7 +1279,7 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         // Second miss: give up.
</span><del>-        vPC[0] = getBytecode(op_put_by_id_generic);
</del><ins>+        vPC[0] = getOpcode(op_put_by_id_generic);
</ins><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -1287,13 +1287,13 @@
</span><span class="cx"> 
</span><span class="cx">     // If baseCell != slot.base(), then baseCell must be a proxy for another object.
</span><span class="cx">     if (baseCell != slot.base()) {
</span><del>-        vPC[0] = getBytecode(op_put_by_id_generic);
</del><ins>+        vPC[0] = getOpcode(op_put_by_id_generic);
</ins><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     // StructureID transition, cache transition info
</span><span class="cx">     if (slot.type() == PutPropertySlot::NewProperty) {
</span><del>-        vPC[0] = getBytecode(op_put_by_id_transition);
</del><ins>+        vPC[0] = getOpcode(op_put_by_id_transition);
</ins><span class="cx">         vPC[4] = structureID-&gt;previousID();
</span><span class="cx">         vPC[5] = structureID;
</span><span class="cx">         StructureIDChain* chain = structureID-&gt;cachedPrototypeChain();
</span><span class="lines">@@ -1301,7 +1301,7 @@
</span><span class="cx">             chain = cachePrototypeChain(callFrame, structureID);
</span><span class="cx">             if (!chain) {
</span><span class="cx">                 // This happens if someone has manually inserted null into the prototype chain
</span><del>-                vPC[0] = getBytecode(op_put_by_id_generic);
</del><ins>+                vPC[0] = getOpcode(op_put_by_id_generic);
</ins><span class="cx">                 return;
</span><span class="cx">             }
</span><span class="cx">         }
</span><span class="lines">@@ -1311,7 +1311,7 @@
</span><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    vPC[0] = getBytecode(op_put_by_id_replace);
</del><ins>+    vPC[0] = getOpcode(op_put_by_id_replace);
</ins><span class="cx">     vPC[5] = slot.cachedOffset();
</span><span class="cx">     codeBlock-&gt;refStructureIDs(vPC);
</span><span class="cx"> }
</span><span class="lines">@@ -1319,42 +1319,42 @@
</span><span class="cx"> NEVER_INLINE void BytecodeInterpreter::uncachePutByID(CodeBlock* codeBlock, Instruction* vPC)
</span><span class="cx"> {
</span><span class="cx">     codeBlock-&gt;derefStructureIDs(vPC);
</span><del>-    vPC[0] = getBytecode(op_put_by_id);
</del><ins>+    vPC[0] = getOpcode(op_put_by_id);
</ins><span class="cx">     vPC[4] = 0;
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> NEVER_INLINE void BytecodeInterpreter::tryCacheGetByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const Identifier&amp; propertyName, const PropertySlot&amp; slot)
</span><span class="cx"> {
</span><span class="cx">     // Recursive invocation may already have specialized this instruction.
</span><del>-    if (vPC[0].u.bytecode != getBytecode(op_get_by_id))
</del><ins>+    if (vPC[0].u.opcode != getOpcode(op_get_by_id))
</ins><span class="cx">         return;
</span><span class="cx"> 
</span><span class="cx">     // FIXME: Cache property access for immediates.
</span><span class="cx">     if (JSImmediate::isImmediate(baseValue)) {
</span><del>-        vPC[0] = getBytecode(op_get_by_id_generic);
</del><ins>+        vPC[0] = getOpcode(op_get_by_id_generic);
</ins><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     if (isJSArray(baseValue) &amp;&amp; propertyName == callFrame-&gt;propertyNames().length) {
</span><del>-        vPC[0] = getBytecode(op_get_array_length);
</del><ins>+        vPC[0] = getOpcode(op_get_array_length);
</ins><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     if (isJSString(baseValue) &amp;&amp; propertyName == callFrame-&gt;propertyNames().length) {
</span><del>-        vPC[0] = getBytecode(op_get_string_length);
</del><ins>+        vPC[0] = getOpcode(op_get_string_length);
</ins><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     // Uncacheable: give up.
</span><span class="cx">     if (!slot.isCacheable()) {
</span><del>-        vPC[0] = getBytecode(op_get_by_id_generic);
</del><ins>+        vPC[0] = getOpcode(op_get_by_id_generic);
</ins><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     StructureID* structureID = asCell(baseValue)-&gt;structureID();
</span><span class="cx"> 
</span><span class="cx">     if (structureID-&gt;isDictionary()) {
</span><del>-        vPC[0] = getBytecode(op_get_by_id_generic);
</del><ins>+        vPC[0] = getOpcode(op_get_by_id_generic);
</ins><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -1368,14 +1368,14 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         // Second miss: give up.
</span><del>-        vPC[0] = getBytecode(op_get_by_id_generic);
</del><ins>+        vPC[0] = getOpcode(op_get_by_id_generic);
</ins><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     // Cache hit: Specialize instruction and ref StructureIDs.
</span><span class="cx"> 
</span><span class="cx">     if (slot.slotBase() == baseValue) {
</span><del>-        vPC[0] = getBytecode(op_get_by_id_self);
</del><ins>+        vPC[0] = getOpcode(op_get_by_id_self);
</ins><span class="cx">         vPC[5] = slot.cachedOffset();
</span><span class="cx"> 
</span><span class="cx">         codeBlock-&gt;refStructureIDs(vPC);
</span><span class="lines">@@ -1395,7 +1395,7 @@
</span><span class="cx">             asCell(baseValue)-&gt;structureID()-&gt;setCachedPrototypeChain(0);
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        vPC[0] = getBytecode(op_get_by_id_proto);
</del><ins>+        vPC[0] = getOpcode(op_get_by_id_proto);
</ins><span class="cx">         vPC[5] = baseObject-&gt;structureID();
</span><span class="cx">         vPC[6] = slot.cachedOffset();
</span><span class="cx"> 
</span><span class="lines">@@ -1411,7 +1411,7 @@
</span><span class="cx">         // If we didn't find base in baseValue's prototype chain, then baseValue
</span><span class="cx">         // must be a proxy for another object.
</span><span class="cx">         if (v-&gt;isNull()) {
</span><del>-            vPC[0] = getBytecode(op_get_by_id_generic);
</del><ins>+            vPC[0] = getOpcode(op_get_by_id_generic);
</ins><span class="cx">             return;
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="lines">@@ -1433,7 +1433,7 @@
</span><span class="cx">         chain = cachePrototypeChain(callFrame, structureID);
</span><span class="cx">     ASSERT(chain);
</span><span class="cx"> 
</span><del>-    vPC[0] = getBytecode(op_get_by_id_chain);
</del><ins>+    vPC[0] = getOpcode(op_get_by_id_chain);
</ins><span class="cx">     vPC[4] = structureID;
</span><span class="cx">     vPC[5] = chain;
</span><span class="cx">     vPC[6] = count;
</span><span class="lines">@@ -1444,7 +1444,7 @@
</span><span class="cx"> NEVER_INLINE void BytecodeInterpreter::uncacheGetByID(CodeBlock* codeBlock, Instruction* vPC)
</span><span class="cx"> {
</span><span class="cx">     codeBlock-&gt;derefStructureIDs(vPC);
</span><del>-    vPC[0] = getBytecode(op_get_by_id);
</del><ins>+    vPC[0] = getOpcode(op_get_by_id);
</ins><span class="cx">     vPC[4] = 0;
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="lines">@@ -1454,14 +1454,14 @@
</span><span class="cx">     // here because our labels are only in scope inside this function.
</span><span class="cx">     if (flag == InitializeAndReturn) {
</span><span class="cx">         #if HAVE(COMPUTED_GOTO)
</span><del>-            #define ADD_BYTECODE(id) m_bytecodeTable[id] = &amp;&amp;id;
-                FOR_EACH_BYTECODE_ID(ADD_BYTECODE);
</del><ins>+            #define ADD_BYTECODE(id) m_opcodeTable[id] = &amp;&amp;id;
+                FOR_EACH_OPCODE_ID(ADD_BYTECODE);
</ins><span class="cx">             #undef ADD_BYTECODE
</span><span class="cx"> 
</span><del>-            #define ADD_BYTECODE_ID(id) m_bytecodeIDTable.add(&amp;&amp;id, id);
-                FOR_EACH_BYTECODE_ID(ADD_BYTECODE_ID);
-            #undef ADD_BYTECODE_ID
-            ASSERT(m_bytecodeIDTable.size() == numBytecodeIDs);
</del><ins>+            #define ADD_OPCODE_ID(id) m_opcodeIDTable.add(&amp;&amp;id, id);
+                FOR_EACH_OPCODE_ID(ADD_OPCODE_ID);
+            #undef ADD_OPCODE_ID
+            ASSERT(m_opcodeIDTable.size() == numOpcodeIDs);
</ins><span class="cx">             op_throw_end_indirect = &amp;&amp;op_throw_end;
</span><span class="cx">             op_call_indirect = &amp;&amp;op_call;
</span><span class="cx">         #endif // HAVE(COMPUTED_GOTO)
</span><span class="lines">@@ -1489,8 +1489,8 @@
</span><span class="cx">         } \
</span><span class="cx">     } while (0)
</span><span class="cx"> 
</span><del>-#if ENABLE(BYTECODE_STATS)
-    BytecodeStats::resetLastInstruction();
</del><ins>+#if ENABLE(OPCODE_STATS)
+    OpcodeStats::resetLastInstruction();
</ins><span class="cx"> #endif
</span><span class="cx"> 
</span><span class="cx"> #define CHECK_FOR_TIMEOUT() \
</span><span class="lines">@@ -1500,7 +1500,7 @@
</span><span class="cx">         tickCount = m_ticksUntilNextTimeoutCheck; \
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     #define SAMPLE(codeBlock, vPC) m_sampler-&gt;sample(codeBlock, vPC)
</span><span class="cx">     #define CTI_SAMPLER ARG_globalData-&gt;interpreter-&gt;sampler()
</span><span class="cx"> #else
</span><span class="lines">@@ -1509,26 +1509,26 @@
</span><span class="cx"> #endif
</span><span class="cx"> 
</span><span class="cx"> #if HAVE(COMPUTED_GOTO)
</span><del>-    #define NEXT_BYTECODE SAMPLE(callFrame-&gt;codeBlock(), vPC); goto *vPC-&gt;u.bytecode
-#if ENABLE(BYTECODE_STATS)
-    #define BEGIN_BYTECODE(bytecode) bytecode: BytecodeStats::recordInstruction(bytecode);
</del><ins>+    #define NEXT_INSTRUCTION SAMPLE(callFrame-&gt;codeBlock(), vPC); goto *vPC-&gt;u.opcode
+#if ENABLE(OPCODE_STATS)
+    #define DEFINE_OPCODE(opcode) opcode: OpcodeStats::recordInstruction(opcode);
</ins><span class="cx"> #else
</span><del>-    #define BEGIN_BYTECODE(bytecode) bytecode:
</del><ins>+    #define DEFINE_OPCODE(opcode) opcode:
</ins><span class="cx"> #endif
</span><del>-    NEXT_BYTECODE;
</del><ins>+    NEXT_INSTRUCTION;
</ins><span class="cx"> #else
</span><del>-    #define NEXT_BYTECODE SAMPLE(callFrame-&gt;codeBlock(), vPC); goto interpreterLoopStart
-#if ENABLE(BYTECODE_STATS)
-    #define BEGIN_BYTECODE(bytecode) case bytecode: BytecodeStats::recordInstruction(bytecode);
</del><ins>+    #define NEXT_INSTRUCTION SAMPLE(callFrame-&gt;codeBlock(), vPC); goto interpreterLoopStart
+#if ENABLE(OPCODE_STATS)
+    #define DEFINE_OPCODE(opcode) case opcode: OpcodeStats::recordInstruction(opcode);
</ins><span class="cx"> #else
</span><del>-    #define BEGIN_BYTECODE(bytecode) case bytecode:
</del><ins>+    #define DEFINE_OPCODE(opcode) case opcode:
</ins><span class="cx"> #endif
</span><span class="cx">     while (1) { // iterator loop begins
</span><span class="cx">     interpreterLoopStart:;
</span><del>-    switch (vPC-&gt;u.bytecode)
</del><ins>+    switch (vPC-&gt;u.opcode)
</ins><span class="cx"> #endif
</span><span class="cx">     {
</span><del>-    BEGIN_BYTECODE(op_new_object) {
</del><ins>+    DEFINE_OPCODE(op_new_object) {
</ins><span class="cx">         /* new_object dst(r)
</span><span class="cx"> 
</span><span class="cx">            Constructs a new empty Object instance using the original
</span><span class="lines">@@ -1538,9 +1538,9 @@
</span><span class="cx">         callFrame[dst] = constructEmptyObject(callFrame);
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_new_array) {
</del><ins>+    DEFINE_OPCODE(op_new_array) {
</ins><span class="cx">         /* new_array dst(r) firstArg(r) argCount(n)
</span><span class="cx"> 
</span><span class="cx">            Constructs a new Array instance using the original
</span><span class="lines">@@ -1555,9 +1555,9 @@
</span><span class="cx">         callFrame[dst] = constructArray(callFrame, args);
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_new_regexp) {
</del><ins>+    DEFINE_OPCODE(op_new_regexp) {
</ins><span class="cx">         /* new_regexp dst(r) regExp(re)
</span><span class="cx"> 
</span><span class="cx">            Constructs a new RegExp instance using the original
</span><span class="lines">@@ -1569,9 +1569,9 @@
</span><span class="cx">         callFrame[dst] = new (globalData) RegExpObject(callFrame-&gt;scopeChain()-&gt;globalObject()-&gt;regExpStructure(), callFrame-&gt;codeBlock()-&gt;regexps[regExp]);
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_mov) {
</del><ins>+    DEFINE_OPCODE(op_mov) {
</ins><span class="cx">         /* mov dst(r) src(r)
</span><span class="cx"> 
</span><span class="cx">            Copies register src to register dst.
</span><span class="lines">@@ -1581,9 +1581,9 @@
</span><span class="cx">         callFrame[dst] = callFrame[src];
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_eq) {
</del><ins>+    DEFINE_OPCODE(op_eq) {
</ins><span class="cx">         /* eq dst(r) src1(r) src2(r)
</span><span class="cx"> 
</span><span class="cx">            Checks whether register src1 and register src2 are equal,
</span><span class="lines">@@ -1602,9 +1602,9 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_eq_null) {
</del><ins>+    DEFINE_OPCODE(op_eq_null) {
</ins><span class="cx">         /* eq_null dst(r) src(r)
</span><span class="cx"> 
</span><span class="cx">            Checks whether register src is null, as with the ECMAScript '!='
</span><span class="lines">@@ -1616,14 +1616,14 @@
</span><span class="cx">         if (src-&gt;isUndefinedOrNull()) {
</span><span class="cx">             callFrame[dst] = jsBoolean(true);
</span><span class="cx">             ++vPC;
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx">         
</span><span class="cx">         callFrame[dst] = jsBoolean(!JSImmediate::isImmediate(src) &amp;&amp; src-&gt;asCell()-&gt;structureID()-&gt;typeInfo().masqueradesAsUndefined());
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_neq) {
</del><ins>+    DEFINE_OPCODE(op_neq) {
</ins><span class="cx">         /* neq dst(r) src1(r) src2(r)
</span><span class="cx"> 
</span><span class="cx">            Checks whether register src1 and register src2 are not
</span><span class="lines">@@ -1642,9 +1642,9 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_neq_null) {
</del><ins>+    DEFINE_OPCODE(op_neq_null) {
</ins><span class="cx">         /* neq_null dst(r) src(r)
</span><span class="cx"> 
</span><span class="cx">            Checks whether register src is not null, as with the ECMAScript '!='
</span><span class="lines">@@ -1656,14 +1656,14 @@
</span><span class="cx">         if (src-&gt;isUndefinedOrNull()) {
</span><span class="cx">             callFrame[dst] = jsBoolean(false);
</span><span class="cx">             ++vPC;
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx">         
</span><span class="cx">         callFrame[dst] = jsBoolean(JSImmediate::isImmediate(src) || !asCell(src)-&gt;structureID()-&gt;typeInfo().masqueradesAsUndefined());
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_stricteq) {
</del><ins>+    DEFINE_OPCODE(op_stricteq) {
</ins><span class="cx">         /* stricteq dst(r) src1(r) src2(r)
</span><span class="cx"> 
</span><span class="cx">            Checks whether register src1 and register src2 are strictly
</span><span class="lines">@@ -1681,9 +1681,9 @@
</span><span class="cx">             callFrame[dst] = jsBoolean(strictEqualSlowCase(src1, src2));
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_nstricteq) {
</del><ins>+    DEFINE_OPCODE(op_nstricteq) {
</ins><span class="cx">         /* nstricteq dst(r) src1(r) src2(r)
</span><span class="cx"> 
</span><span class="cx">            Checks whether register src1 and register src2 are not
</span><span class="lines">@@ -1702,9 +1702,9 @@
</span><span class="cx">             callFrame[dst] = jsBoolean(!strictEqualSlowCase(src1, src2));
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_less) {
</del><ins>+    DEFINE_OPCODE(op_less) {
</ins><span class="cx">         /* less dst(r) src1(r) src2(r)
</span><span class="cx"> 
</span><span class="cx">            Checks whether register src1 is less than register src2, as
</span><span class="lines">@@ -1719,9 +1719,9 @@
</span><span class="cx">         callFrame[dst] = result;
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_lesseq) {
</del><ins>+    DEFINE_OPCODE(op_lesseq) {
</ins><span class="cx">         /* lesseq dst(r) src1(r) src2(r)
</span><span class="cx"> 
</span><span class="cx">            Checks whether register src1 is less than or equal to
</span><span class="lines">@@ -1736,9 +1736,9 @@
</span><span class="cx">         callFrame[dst] = result;
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_pre_inc) {
</del><ins>+    DEFINE_OPCODE(op_pre_inc) {
</ins><span class="cx">         /* pre_inc srcDst(r)
</span><span class="cx"> 
</span><span class="cx">            Converts register srcDst to number, adds one, and puts the result
</span><span class="lines">@@ -1755,9 +1755,9 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_pre_dec) {
</del><ins>+    DEFINE_OPCODE(op_pre_dec) {
</ins><span class="cx">         /* pre_dec srcDst(r)
</span><span class="cx"> 
</span><span class="cx">            Converts register srcDst to number, subtracts one, and puts the result
</span><span class="lines">@@ -1774,9 +1774,9 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_post_inc) {
</del><ins>+    DEFINE_OPCODE(op_post_inc) {
</ins><span class="cx">         /* post_inc dst(r) srcDst(r)
</span><span class="cx"> 
</span><span class="cx">            Converts register srcDst to number. The number itself is
</span><span class="lines">@@ -1797,9 +1797,9 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_post_dec) {
</del><ins>+    DEFINE_OPCODE(op_post_dec) {
</ins><span class="cx">         /* post_dec dst(r) srcDst(r)
</span><span class="cx"> 
</span><span class="cx">            Converts register srcDst to number. The number itself is
</span><span class="lines">@@ -1820,9 +1820,9 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_to_jsnumber) {
</del><ins>+    DEFINE_OPCODE(op_to_jsnumber) {
</ins><span class="cx">         /* to_jsnumber dst(r) src(r)
</span><span class="cx"> 
</span><span class="cx">            Converts register src to number, and puts the result
</span><span class="lines">@@ -1842,9 +1842,9 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_negate) {
</del><ins>+    DEFINE_OPCODE(op_negate) {
</ins><span class="cx">         /* negate dst(r) src(r)
</span><span class="cx"> 
</span><span class="cx">            Converts register src to number, negates it, and puts the
</span><span class="lines">@@ -1863,9 +1863,9 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_add) {
</del><ins>+    DEFINE_OPCODE(op_add) {
</ins><span class="cx">         /* add dst(r) src1(r) src2(r)
</span><span class="cx"> 
</span><span class="cx">            Adds register src1 and register src2, and puts the result
</span><span class="lines">@@ -1883,9 +1883,9 @@
</span><span class="cx">             callFrame[dst] = result;
</span><span class="cx">         }
</span><span class="cx">         vPC += 2;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_mul) {
</del><ins>+    DEFINE_OPCODE(op_mul) {
</ins><span class="cx">         /* mul dst(r) src1(r) src2(r)
</span><span class="cx"> 
</span><span class="cx">            Multiplies register src1 and register src2 (converted to
</span><span class="lines">@@ -1912,9 +1912,9 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         vPC += 2;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_div) {
</del><ins>+    DEFINE_OPCODE(op_div) {
</ins><span class="cx">         /* div dst(r) dividend(r) divisor(r)
</span><span class="cx"> 
</span><span class="cx">            Divides register dividend (converted to number) by the
</span><span class="lines">@@ -1934,9 +1934,9 @@
</span><span class="cx">             callFrame[dst] = result;
</span><span class="cx">         }
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_mod) {
</del><ins>+    DEFINE_OPCODE(op_mod) {
</ins><span class="cx">         /* mod dst(r) dividend(r) divisor(r)
</span><span class="cx"> 
</span><span class="cx">            Divides register dividend (converted to number) by
</span><span class="lines">@@ -1953,7 +1953,7 @@
</span><span class="cx">         if (JSImmediate::areBothImmediateNumbers(dividendValue, divisorValue) &amp;&amp; divisorValue != JSImmediate::from(0)) {
</span><span class="cx">             callFrame[dst] = JSImmediate::from(JSImmediate::getTruncatedInt32(dividendValue) % JSImmediate::getTruncatedInt32(divisorValue));
</span><span class="cx">             ++vPC;
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         double d = dividendValue-&gt;toNumber(callFrame);
</span><span class="lines">@@ -1961,9 +1961,9 @@
</span><span class="cx">         VM_CHECK_EXCEPTION();
</span><span class="cx">         callFrame[dst] = result;
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_sub) {
</del><ins>+    DEFINE_OPCODE(op_sub) {
</ins><span class="cx">         /* sub dst(r) src1(r) src2(r)
</span><span class="cx"> 
</span><span class="cx">            Subtracts register src2 (converted to number) from register
</span><span class="lines">@@ -1985,9 +1985,9 @@
</span><span class="cx">             callFrame[dst] = result;
</span><span class="cx">         }
</span><span class="cx">         vPC += 2;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_lshift) {
</del><ins>+    DEFINE_OPCODE(op_lshift) {
</ins><span class="cx">         /* lshift dst(r) val(r) shift(r)
</span><span class="cx"> 
</span><span class="cx">            Performs left shift of register val (converted to int32) by
</span><span class="lines">@@ -2010,9 +2010,9 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_rshift) {
</del><ins>+    DEFINE_OPCODE(op_rshift) {
</ins><span class="cx">         /* rshift dst(r) val(r) shift(r)
</span><span class="cx"> 
</span><span class="cx">            Performs arithmetic right shift of register val (converted
</span><span class="lines">@@ -2035,9 +2035,9 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_urshift) {
</del><ins>+    DEFINE_OPCODE(op_urshift) {
</ins><span class="cx">         /* rshift dst(r) val(r) shift(r)
</span><span class="cx"> 
</span><span class="cx">            Performs logical right shift of register val (converted
</span><span class="lines">@@ -2056,9 +2056,9 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_bitand) {
</del><ins>+    DEFINE_OPCODE(op_bitand) {
</ins><span class="cx">         /* bitand dst(r) src1(r) src2(r)
</span><span class="cx"> 
</span><span class="cx">            Computes bitwise AND of register src1 (converted to int32)
</span><span class="lines">@@ -2081,9 +2081,9 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         vPC += 2;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_bitxor) {
</del><ins>+    DEFINE_OPCODE(op_bitxor) {
</ins><span class="cx">         /* bitxor dst(r) src1(r) src2(r)
</span><span class="cx"> 
</span><span class="cx">            Computes bitwise XOR of register src1 (converted to int32)
</span><span class="lines">@@ -2106,9 +2106,9 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         vPC += 2;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_bitor) {
</del><ins>+    DEFINE_OPCODE(op_bitor) {
</ins><span class="cx">         /* bitor dst(r) src1(r) src2(r)
</span><span class="cx"> 
</span><span class="cx">            Computes bitwise OR of register src1 (converted to int32)
</span><span class="lines">@@ -2131,9 +2131,9 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         vPC += 2;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_bitnot) {
</del><ins>+    DEFINE_OPCODE(op_bitnot) {
</ins><span class="cx">         /* bitnot dst(r) src(r)
</span><span class="cx"> 
</span><span class="cx">            Computes bitwise NOT of register src1 (converted to int32),
</span><span class="lines">@@ -2150,9 +2150,9 @@
</span><span class="cx">             callFrame[dst] = result;
</span><span class="cx">         }
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_not) {
</del><ins>+    DEFINE_OPCODE(op_not) {
</ins><span class="cx">         /* not dst(r) src(r)
</span><span class="cx"> 
</span><span class="cx">            Computes logical NOT of register src (converted to
</span><span class="lines">@@ -2165,9 +2165,9 @@
</span><span class="cx">         callFrame[dst] = result;
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_instanceof) {
</del><ins>+    DEFINE_OPCODE(op_instanceof) {
</ins><span class="cx">         /* instanceof dst(r) value(r) constructor(r) constructorProto(r)
</span><span class="cx"> 
</span><span class="cx">            Tests whether register value is an instance of register
</span><span class="lines">@@ -2194,9 +2194,9 @@
</span><span class="cx">         callFrame[dst] = jsBoolean(baseObj-&gt;structureID()-&gt;typeInfo().implementsHasInstance() ? baseObj-&gt;hasInstance(callFrame, callFrame[value].jsValue(callFrame), callFrame[baseProto].jsValue(callFrame)) : false);
</span><span class="cx"> 
</span><span class="cx">         vPC += 5;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_typeof) {
</del><ins>+    DEFINE_OPCODE(op_typeof) {
</ins><span class="cx">         /* typeof dst(r) src(r)
</span><span class="cx"> 
</span><span class="cx">            Determines the type string for src according to ECMAScript
</span><span class="lines">@@ -2207,9 +2207,9 @@
</span><span class="cx">         callFrame[dst] = jsTypeStringForValue(callFrame, callFrame[src].jsValue(callFrame));
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_is_undefined) {
</del><ins>+    DEFINE_OPCODE(op_is_undefined) {
</ins><span class="cx">         /* is_undefined dst(r) src(r)
</span><span class="cx"> 
</span><span class="cx">            Determines whether the type string for src according to
</span><span class="lines">@@ -2222,9 +2222,9 @@
</span><span class="cx">         callFrame[dst] = jsBoolean(JSImmediate::isImmediate(v) ? v-&gt;isUndefined() : v-&gt;asCell()-&gt;structureID()-&gt;typeInfo().masqueradesAsUndefined());
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_is_boolean) {
</del><ins>+    DEFINE_OPCODE(op_is_boolean) {
</ins><span class="cx">         /* is_boolean dst(r) src(r)
</span><span class="cx"> 
</span><span class="cx">            Determines whether the type string for src according to
</span><span class="lines">@@ -2236,9 +2236,9 @@
</span><span class="cx">         callFrame[dst] = jsBoolean(callFrame[src].jsValue(callFrame)-&gt;isBoolean());
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_is_number) {
</del><ins>+    DEFINE_OPCODE(op_is_number) {
</ins><span class="cx">         /* is_number dst(r) src(r)
</span><span class="cx"> 
</span><span class="cx">            Determines whether the type string for src according to
</span><span class="lines">@@ -2250,9 +2250,9 @@
</span><span class="cx">         callFrame[dst] = jsBoolean(callFrame[src].jsValue(callFrame)-&gt;isNumber());
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_is_string) {
</del><ins>+    DEFINE_OPCODE(op_is_string) {
</ins><span class="cx">         /* is_string dst(r) src(r)
</span><span class="cx"> 
</span><span class="cx">            Determines whether the type string for src according to
</span><span class="lines">@@ -2264,9 +2264,9 @@
</span><span class="cx">         callFrame[dst] = jsBoolean(callFrame[src].jsValue(callFrame)-&gt;isString());
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_is_object) {
</del><ins>+    DEFINE_OPCODE(op_is_object) {
</ins><span class="cx">         /* is_object dst(r) src(r)
</span><span class="cx"> 
</span><span class="cx">            Determines whether the type string for src according to
</span><span class="lines">@@ -2278,9 +2278,9 @@
</span><span class="cx">         callFrame[dst] = jsBoolean(jsIsObjectType(callFrame[src].jsValue(callFrame)));
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_is_function) {
</del><ins>+    DEFINE_OPCODE(op_is_function) {
</ins><span class="cx">         /* is_function dst(r) src(r)
</span><span class="cx"> 
</span><span class="cx">            Determines whether the type string for src according to
</span><span class="lines">@@ -2292,9 +2292,9 @@
</span><span class="cx">         callFrame[dst] = jsBoolean(jsIsFunctionType(callFrame[src].jsValue(callFrame)));
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_in) {
</del><ins>+    DEFINE_OPCODE(op_in) {
</ins><span class="cx">         /* in dst(r) property(r) base(r)
</span><span class="cx"> 
</span><span class="cx">            Tests whether register base has a property named register
</span><span class="lines">@@ -2325,9 +2325,9 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_resolve) {
</del><ins>+    DEFINE_OPCODE(op_resolve) {
</ins><span class="cx">         /* resolve dst(r) property(id)
</span><span class="cx"> 
</span><span class="cx">            Looks up the property named by identifier property in the
</span><span class="lines">@@ -2338,9 +2338,9 @@
</span><span class="cx">             goto vm_throw;
</span><span class="cx"> 
</span><span class="cx">         vPC += 3;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_resolve_skip) {
</del><ins>+    DEFINE_OPCODE(op_resolve_skip) {
</ins><span class="cx">         /* resolve_skip dst(r) property(id) skip(n)
</span><span class="cx"> 
</span><span class="cx">          Looks up the property named by identifier property in the
</span><span class="lines">@@ -2352,9 +2352,9 @@
</span><span class="cx"> 
</span><span class="cx">         vPC += 4;
</span><span class="cx"> 
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_resolve_global) {
</del><ins>+    DEFINE_OPCODE(op_resolve_global) {
</ins><span class="cx">         /* resolve_skip dst(r) globalObject(c) property(id) structureID(sID) offset(n)
</span><span class="cx">          
</span><span class="cx">            Performs a dynamic property lookup for the given property, on the provided
</span><span class="lines">@@ -2367,9 +2367,9 @@
</span><span class="cx">         
</span><span class="cx">         vPC += 6;
</span><span class="cx">         
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_get_global_var) {
</del><ins>+    DEFINE_OPCODE(op_get_global_var) {
</ins><span class="cx">         /* get_global_var dst(r) globalObject(c) index(n)
</span><span class="cx"> 
</span><span class="cx">            Gets the global var at global slot index and places it in register dst.
</span><span class="lines">@@ -2381,9 +2381,9 @@
</span><span class="cx"> 
</span><span class="cx">         callFrame[dst] = scope-&gt;registerAt(index);
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_put_global_var) {
</del><ins>+    DEFINE_OPCODE(op_put_global_var) {
</ins><span class="cx">         /* put_global_var globalObject(c) index(n) value(r)
</span><span class="cx">          
</span><span class="cx">            Puts value into global slot index.
</span><span class="lines">@@ -2395,9 +2395,9 @@
</span><span class="cx">         
</span><span class="cx">         scope-&gt;registerAt(index) = callFrame[value].jsValue(callFrame);
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }            
</span><del>-    BEGIN_BYTECODE(op_get_scoped_var) {
</del><ins>+    DEFINE_OPCODE(op_get_scoped_var) {
</ins><span class="cx">         /* get_scoped_var dst(r) index(n) skip(n)
</span><span class="cx"> 
</span><span class="cx">          Loads the contents of the index-th local from the scope skip nodes from
</span><span class="lines">@@ -2420,9 +2420,9 @@
</span><span class="cx">         JSVariableObject* scope = static_cast&lt;JSVariableObject*&gt;(*iter);
</span><span class="cx">         callFrame[dst] = scope-&gt;registerAt(index);
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_put_scoped_var) {
</del><ins>+    DEFINE_OPCODE(op_put_scoped_var) {
</ins><span class="cx">         /* put_scoped_var index(n) skip(n) value(r)
</span><span class="cx"> 
</span><span class="cx">          */
</span><span class="lines">@@ -2443,9 +2443,9 @@
</span><span class="cx">         JSVariableObject* scope = static_cast&lt;JSVariableObject*&gt;(*iter);
</span><span class="cx">         scope-&gt;registerAt(index) = callFrame[value].jsValue(callFrame);
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_resolve_base) {
</del><ins>+    DEFINE_OPCODE(op_resolve_base) {
</ins><span class="cx">         /* resolve_base dst(r) property(id)
</span><span class="cx"> 
</span><span class="cx">            Searches the scope chain for an object containing
</span><span class="lines">@@ -2456,9 +2456,9 @@
</span><span class="cx">         resolveBase(callFrame, vPC);
</span><span class="cx"> 
</span><span class="cx">         vPC += 3;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_resolve_with_base) {
</del><ins>+    DEFINE_OPCODE(op_resolve_with_base) {
</ins><span class="cx">         /* resolve_with_base baseDst(r) propDst(r) property(id)
</span><span class="cx"> 
</span><span class="cx">            Searches the scope chain for an object containing
</span><span class="lines">@@ -2474,9 +2474,9 @@
</span><span class="cx">             goto vm_throw;
</span><span class="cx"> 
</span><span class="cx">         vPC += 4;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_resolve_func) {
</del><ins>+    DEFINE_OPCODE(op_resolve_func) {
</ins><span class="cx">         /* resolve_func baseDst(r) funcDst(r) property(id)
</span><span class="cx"> 
</span><span class="cx">            Searches the scope chain for an object containing
</span><span class="lines">@@ -2495,9 +2495,9 @@
</span><span class="cx">             goto vm_throw;
</span><span class="cx"> 
</span><span class="cx">         vPC += 4;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_get_by_id) {
</del><ins>+    DEFINE_OPCODE(op_get_by_id) {
</ins><span class="cx">         /* get_by_id dst(r) base(r) property(id) structureID(sID) nop(n) nop(n) nop(n)
</span><span class="cx"> 
</span><span class="cx">            Generic property access: Gets the property named by identifier
</span><span class="lines">@@ -2518,9 +2518,9 @@
</span><span class="cx"> 
</span><span class="cx">         callFrame[dst] = result;
</span><span class="cx">         vPC += 8;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_get_by_id_self) {
</del><ins>+    DEFINE_OPCODE(op_get_by_id_self) {
</ins><span class="cx">         /* op_get_by_id_self dst(r) base(r) property(id) structureID(sID) offset(n) nop(n) nop(n)
</span><span class="cx"> 
</span><span class="cx">            Cached property access: Attempts to get a cached property from the
</span><span class="lines">@@ -2544,14 +2544,14 @@
</span><span class="cx">                 callFrame[dst] = baseObject-&gt;getDirectOffset(offset);
</span><span class="cx"> 
</span><span class="cx">                 vPC += 8;
</span><del>-                NEXT_BYTECODE;
</del><ins>+                NEXT_INSTRUCTION;
</ins><span class="cx">             }
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         uncacheGetByID(callFrame-&gt;codeBlock(), vPC);
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_get_by_id_proto) {
</del><ins>+    DEFINE_OPCODE(op_get_by_id_proto) {
</ins><span class="cx">         /* op_get_by_id_proto dst(r) base(r) property(id) structureID(sID) protoStructureID(sID) offset(n) nop(n)
</span><span class="cx"> 
</span><span class="cx">            Cached property access: Attempts to get a cached property from the
</span><span class="lines">@@ -2578,15 +2578,15 @@
</span><span class="cx">                     callFrame[dst] = protoObject-&gt;getDirectOffset(offset);
</span><span class="cx"> 
</span><span class="cx">                     vPC += 8;
</span><del>-                    NEXT_BYTECODE;
</del><ins>+                    NEXT_INSTRUCTION;
</ins><span class="cx">                 }
</span><span class="cx">             }
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         uncacheGetByID(callFrame-&gt;codeBlock(), vPC);
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_get_by_id_chain) {
</del><ins>+    DEFINE_OPCODE(op_get_by_id_chain) {
</ins><span class="cx">         /* op_get_by_id_chain dst(r) base(r) property(id) structureID(sID) structureIDChain(sIDc) count(n) offset(n)
</span><span class="cx"> 
</span><span class="cx">            Cached property access: Attempts to get a cached property from the
</span><span class="lines">@@ -2619,16 +2619,16 @@
</span><span class="cx">                         callFrame[dst] = baseObject-&gt;getDirectOffset(offset);
</span><span class="cx"> 
</span><span class="cx">                         vPC += 8;
</span><del>-                        NEXT_BYTECODE;
</del><ins>+                        NEXT_INSTRUCTION;
</ins><span class="cx">                     }
</span><span class="cx">                 }
</span><span class="cx">             }
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         uncacheGetByID(callFrame-&gt;codeBlock(), vPC);
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_get_by_id_generic) {
</del><ins>+    DEFINE_OPCODE(op_get_by_id_generic) {
</ins><span class="cx">         /* op_get_by_id_generic dst(r) base(r) property(id) nop(sID) nop(n) nop(n) nop(n)
</span><span class="cx"> 
</span><span class="cx">            Generic property access: Gets the property named by identifier
</span><span class="lines">@@ -2646,9 +2646,9 @@
</span><span class="cx"> 
</span><span class="cx">         callFrame[dst] = result;
</span><span class="cx">         vPC += 8;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_get_array_length) {
</del><ins>+    DEFINE_OPCODE(op_get_array_length) {
</ins><span class="cx">         /* op_get_array_length dst(r) base(r) property(id) nop(sID) nop(n) nop(n) nop(n)
</span><span class="cx"> 
</span><span class="cx">            Cached property access: Gets the length of the array in register base,
</span><span class="lines">@@ -2662,13 +2662,13 @@
</span><span class="cx">             int dst = vPC[1].u.operand;
</span><span class="cx">             callFrame[dst] = jsNumber(callFrame, asArray(baseValue)-&gt;length());
</span><span class="cx">             vPC += 8;
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         uncacheGetByID(callFrame-&gt;codeBlock(), vPC);
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_get_string_length) {
</del><ins>+    DEFINE_OPCODE(op_get_string_length) {
</ins><span class="cx">         /* op_get_string_length dst(r) base(r) property(id) nop(sID) nop(n) nop(n) nop(n)
</span><span class="cx"> 
</span><span class="cx">            Cached property access: Gets the length of the string in register base,
</span><span class="lines">@@ -2682,19 +2682,19 @@
</span><span class="cx">             int dst = vPC[1].u.operand;
</span><span class="cx">             callFrame[dst] = jsNumber(callFrame, asString(baseValue)-&gt;value().size());
</span><span class="cx">             vPC += 8;
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         uncacheGetByID(callFrame-&gt;codeBlock(), vPC);
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_put_by_id) {
</del><ins>+    DEFINE_OPCODE(op_put_by_id) {
</ins><span class="cx">         /* put_by_id base(r) property(id) value(r) nop(n) nop(n) nop(n) nop(n)
</span><span class="cx"> 
</span><span class="cx">            Generic property access: Sets the property named by identifier
</span><span class="cx">            property, belonging to register base, to register value.
</span><span class="cx"> 
</span><del>-           Unlike many bytecodes, this one does not write any output to
</del><ins>+           Unlike many opcodes, this one does not write any output to
</ins><span class="cx">            the register file.
</span><span class="cx">         */
</span><span class="cx"> 
</span><span class="lines">@@ -2712,9 +2712,9 @@
</span><span class="cx">         tryCachePutByID(callFrame, codeBlock, vPC, baseValue, slot);
</span><span class="cx"> 
</span><span class="cx">         vPC += 8;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_put_by_id_transition) {
</del><ins>+    DEFINE_OPCODE(op_put_by_id_transition) {
</ins><span class="cx">         /* op_put_by_id_transition base(r) property(id) value(r) oldStructureID(sID) newStructureID(sID) structureIDChain(sIDc) offset(n)
</span><span class="cx">          
</span><span class="cx">            Cached property access: Attempts to set a new property with a cached transition
</span><span class="lines">@@ -2722,7 +2722,7 @@
</span><span class="cx">            to register value. If the cache misses, op_put_by_id_transition
</span><span class="cx">            reverts to op_put_by_id_generic.
</span><span class="cx">          
</span><del>-           Unlike many bytecodes, this one does not write any output to
</del><ins>+           Unlike many opcodes, this one does not write any output to
</ins><span class="cx">            the register file.
</span><span class="cx">          */
</span><span class="cx">         int base = vPC[1].u.operand;
</span><span class="lines">@@ -2743,7 +2743,7 @@
</span><span class="cx">                 while (!proto-&gt;isNull()) {
</span><span class="cx">                     if (UNLIKELY(asObject(proto)-&gt;structureID() != (*it).get())) {
</span><span class="cx">                         uncachePutByID(callFrame-&gt;codeBlock(), vPC);
</span><del>-                        NEXT_BYTECODE;
</del><ins>+                        NEXT_INSTRUCTION;
</ins><span class="cx">                     }
</span><span class="cx">                     ++it;
</span><span class="cx">                     proto = asObject(proto)-&gt;structureID()-&gt;prototypeForLookup(callFrame);
</span><span class="lines">@@ -2757,14 +2757,14 @@
</span><span class="cx">                 baseObject-&gt;putDirectOffset(offset, callFrame[value].jsValue(callFrame));
</span><span class="cx"> 
</span><span class="cx">                 vPC += 8;
</span><del>-                NEXT_BYTECODE;
</del><ins>+                NEXT_INSTRUCTION;
</ins><span class="cx">             }
</span><span class="cx">         }
</span><span class="cx">         
</span><span class="cx">         uncachePutByID(callFrame-&gt;codeBlock(), vPC);
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_put_by_id_replace) {
</del><ins>+    DEFINE_OPCODE(op_put_by_id_replace) {
</ins><span class="cx">         /* op_put_by_id_replace base(r) property(id) value(r) structureID(sID) offset(n) nop(n) nop(n)
</span><span class="cx"> 
</span><span class="cx">            Cached property access: Attempts to set a pre-existing, cached
</span><span class="lines">@@ -2772,7 +2772,7 @@
</span><span class="cx">            to register value. If the cache misses, op_put_by_id_replace
</span><span class="cx">            reverts to op_put_by_id.
</span><span class="cx"> 
</span><del>-           Unlike many bytecodes, this one does not write any output to
</del><ins>+           Unlike many opcodes, this one does not write any output to
</ins><span class="cx">            the register file.
</span><span class="cx">         */
</span><span class="cx">         int base = vPC[1].u.operand;
</span><span class="lines">@@ -2792,20 +2792,20 @@
</span><span class="cx">                 baseObject-&gt;putDirectOffset(offset, callFrame[value].jsValue(callFrame));
</span><span class="cx"> 
</span><span class="cx">                 vPC += 8;
</span><del>-                NEXT_BYTECODE;
</del><ins>+                NEXT_INSTRUCTION;
</ins><span class="cx">             }
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         uncachePutByID(callFrame-&gt;codeBlock(), vPC);
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_put_by_id_generic) {
</del><ins>+    DEFINE_OPCODE(op_put_by_id_generic) {
</ins><span class="cx">         /* op_put_by_id_generic base(r) property(id) value(r) nop(n) nop(n) nop(n) nop(n)
</span><span class="cx"> 
</span><span class="cx">            Generic property access: Sets the property named by identifier
</span><span class="cx">            property, belonging to register base, to register value.
</span><span class="cx"> 
</span><del>-           Unlike many bytecodes, this one does not write any output to
</del><ins>+           Unlike many opcodes, this one does not write any output to
</ins><span class="cx">            the register file.
</span><span class="cx">         */
</span><span class="cx">         int base = vPC[1].u.operand;
</span><span class="lines">@@ -2819,9 +2819,9 @@
</span><span class="cx">         VM_CHECK_EXCEPTION();
</span><span class="cx"> 
</span><span class="cx">         vPC += 8;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_del_by_id) {
</del><ins>+    DEFINE_OPCODE(op_del_by_id) {
</ins><span class="cx">         /* del_by_id dst(r) base(r) property(id)
</span><span class="cx"> 
</span><span class="cx">            Converts register base to Object, deletes the property
</span><span class="lines">@@ -2839,9 +2839,9 @@
</span><span class="cx">         VM_CHECK_EXCEPTION();
</span><span class="cx">         callFrame[dst] = result;
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_get_by_val) {
</del><ins>+    DEFINE_OPCODE(op_get_by_val) {
</ins><span class="cx">         /* get_by_val dst(r) base(r) property(r)
</span><span class="cx"> 
</span><span class="cx">            Converts register base to Object, gets the property named
</span><span class="lines">@@ -2879,9 +2879,9 @@
</span><span class="cx">         VM_CHECK_EXCEPTION();
</span><span class="cx">         callFrame[dst] = result;
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_put_by_val) {
</del><ins>+    DEFINE_OPCODE(op_put_by_val) {
</ins><span class="cx">         /* put_by_val base(r) property(r) value(r)
</span><span class="cx"> 
</span><span class="cx">            Sets register value on register base as the property named
</span><span class="lines">@@ -2889,7 +2889,7 @@
</span><span class="cx">            first. register property is nominally converted to string
</span><span class="cx">            but numbers are treated more efficiently.
</span><span class="cx"> 
</span><del>-           Unlike many bytecodes, this one does not write any output to
</del><ins>+           Unlike many opcodes, this one does not write any output to
</ins><span class="cx">            the register file.
</span><span class="cx">         */
</span><span class="cx">         int base = (++vPC)-&gt;u.operand;
</span><span class="lines">@@ -2921,9 +2921,9 @@
</span><span class="cx"> 
</span><span class="cx">         VM_CHECK_EXCEPTION();
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_del_by_val) {
</del><ins>+    DEFINE_OPCODE(op_del_by_val) {
</ins><span class="cx">         /* del_by_val dst(r) base(r) property(r)
</span><span class="cx"> 
</span><span class="cx">            Converts register base to Object, deletes the property
</span><span class="lines">@@ -2952,19 +2952,19 @@
</span><span class="cx">         VM_CHECK_EXCEPTION();
</span><span class="cx">         callFrame[dst] = result;
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_put_by_index) {
</del><ins>+    DEFINE_OPCODE(op_put_by_index) {
</ins><span class="cx">         /* put_by_index base(r) property(n) value(r)
</span><span class="cx"> 
</span><span class="cx">            Sets register value on register base as the property named
</span><span class="cx">            by the immediate number property. Base is converted to
</span><span class="cx">            object first.
</span><span class="cx"> 
</span><del>-           Unlike many bytecodes, this one does not write any output to
</del><ins>+           Unlike many opcodes, this one does not write any output to
</ins><span class="cx">            the register file.
</span><span class="cx"> 
</span><del>-           This bytecode is mainly used to initialize array literals.
</del><ins>+           This opcode is mainly used to initialize array literals.
</ins><span class="cx">         */
</span><span class="cx">         int base = (++vPC)-&gt;u.operand;
</span><span class="cx">         unsigned property = (++vPC)-&gt;u.operand;
</span><span class="lines">@@ -2973,9 +2973,9 @@
</span><span class="cx">         callFrame[base].jsValue(callFrame)-&gt;put(callFrame, property, callFrame[value].jsValue(callFrame));
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_loop) {
</del><ins>+    DEFINE_OPCODE(op_loop) {
</ins><span class="cx">         /* loop target(offset)
</span><span class="cx">          
</span><span class="cx">            Jumps unconditionally to offset target from the current
</span><span class="lines">@@ -2984,29 +2984,29 @@
</span><span class="cx">            Additionally this loop instruction may terminate JS execution is
</span><span class="cx">            the JS timeout is reached.
</span><span class="cx">          */
</span><del>-#if ENABLE(BYTECODE_STATS)
-        BytecodeStats::resetLastInstruction();
</del><ins>+#if ENABLE(OPCODE_STATS)
+        OpcodeStats::resetLastInstruction();
</ins><span class="cx"> #endif
</span><span class="cx">         int target = (++vPC)-&gt;u.operand;
</span><span class="cx">         CHECK_FOR_TIMEOUT();
</span><span class="cx">         vPC += target;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_jmp) {
</del><ins>+    DEFINE_OPCODE(op_jmp) {
</ins><span class="cx">         /* jmp target(offset)
</span><span class="cx"> 
</span><span class="cx">            Jumps unconditionally to offset target from the current
</span><span class="cx">            instruction.
</span><span class="cx">         */
</span><del>-#if ENABLE(BYTECODE_STATS)
-        BytecodeStats::resetLastInstruction();
</del><ins>+#if ENABLE(OPCODE_STATS)
+        OpcodeStats::resetLastInstruction();
</ins><span class="cx"> #endif
</span><span class="cx">         int target = (++vPC)-&gt;u.operand;
</span><span class="cx"> 
</span><span class="cx">         vPC += target;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_loop_if_true) {
</del><ins>+    DEFINE_OPCODE(op_loop_if_true) {
</ins><span class="cx">         /* loop_if_true cond(r) target(offset)
</span><span class="cx">          
</span><span class="cx">            Jumps to offset target from the current instruction, if and
</span><span class="lines">@@ -3020,13 +3020,13 @@
</span><span class="cx">         if (callFrame[cond].jsValue(callFrame)-&gt;toBoolean(callFrame)) {
</span><span class="cx">             vPC += target;
</span><span class="cx">             CHECK_FOR_TIMEOUT();
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx">         
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_jtrue) {
</del><ins>+    DEFINE_OPCODE(op_jtrue) {
</ins><span class="cx">         /* jtrue cond(r) target(offset)
</span><span class="cx"> 
</span><span class="cx">            Jumps to offset target from the current instruction, if and
</span><span class="lines">@@ -3036,13 +3036,13 @@
</span><span class="cx">         int target = (++vPC)-&gt;u.operand;
</span><span class="cx">         if (callFrame[cond].jsValue(callFrame)-&gt;toBoolean(callFrame)) {
</span><span class="cx">             vPC += target;
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_jfalse) {
</del><ins>+    DEFINE_OPCODE(op_jfalse) {
</ins><span class="cx">         /* jfalse cond(r) target(offset)
</span><span class="cx"> 
</span><span class="cx">            Jumps to offset target from the current instruction, if and
</span><span class="lines">@@ -3052,13 +3052,13 @@
</span><span class="cx">         int target = (++vPC)-&gt;u.operand;
</span><span class="cx">         if (!callFrame[cond].jsValue(callFrame)-&gt;toBoolean(callFrame)) {
</span><span class="cx">             vPC += target;
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_jeq_null) {
</del><ins>+    DEFINE_OPCODE(op_jeq_null) {
</ins><span class="cx">         /* jeq_null src(r) target(offset)
</span><span class="cx"> 
</span><span class="cx">            Jumps to offset target from the current instruction, if and
</span><span class="lines">@@ -3070,13 +3070,13 @@
</span><span class="cx"> 
</span><span class="cx">         if (srcValue-&gt;isUndefinedOrNull() || (!JSImmediate::isImmediate(srcValue) &amp;&amp; srcValue-&gt;asCell()-&gt;structureID()-&gt;typeInfo().masqueradesAsUndefined())) {
</span><span class="cx">             vPC += target;
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_jneq_null) {
</del><ins>+    DEFINE_OPCODE(op_jneq_null) {
</ins><span class="cx">         /* jneq_null src(r) target(offset)
</span><span class="cx"> 
</span><span class="cx">            Jumps to offset target from the current instruction, if and
</span><span class="lines">@@ -3088,13 +3088,13 @@
</span><span class="cx"> 
</span><span class="cx">         if (!srcValue-&gt;isUndefinedOrNull() || (!JSImmediate::isImmediate(srcValue) &amp;&amp; !srcValue-&gt;asCell()-&gt;structureID()-&gt;typeInfo().masqueradesAsUndefined())) {
</span><span class="cx">             vPC += target;
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_loop_if_less) {
</del><ins>+    DEFINE_OPCODE(op_loop_if_less) {
</ins><span class="cx">         /* loop_if_less src1(r) src2(r) target(offset)
</span><span class="cx"> 
</span><span class="cx">            Checks whether register src1 is less than register src2, as
</span><span class="lines">@@ -3115,13 +3115,13 @@
</span><span class="cx">         if (result) {
</span><span class="cx">             vPC += target;
</span><span class="cx">             CHECK_FOR_TIMEOUT();
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx">         
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_loop_if_lesseq) {
</del><ins>+    DEFINE_OPCODE(op_loop_if_lesseq) {
</ins><span class="cx">         /* loop_if_lesseq src1(r) src2(r) target(offset)
</span><span class="cx"> 
</span><span class="cx">            Checks whether register src1 is less than or equal to register
</span><span class="lines">@@ -3142,13 +3142,13 @@
</span><span class="cx">         if (result) {
</span><span class="cx">             vPC += target;
</span><span class="cx">             CHECK_FOR_TIMEOUT();
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx">         
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_jnless) {
</del><ins>+    DEFINE_OPCODE(op_jnless) {
</ins><span class="cx">         /* jnless src1(r) src2(r) target(offset)
</span><span class="cx"> 
</span><span class="cx">            Checks whether register src1 is less than register src2, as
</span><span class="lines">@@ -3165,13 +3165,13 @@
</span><span class="cx">         
</span><span class="cx">         if (!result) {
</span><span class="cx">             vPC += target;
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_switch_imm) {
</del><ins>+    DEFINE_OPCODE(op_switch_imm) {
</ins><span class="cx">         /* switch_imm tableIndex(n) defaultOffset(offset) scrutinee(r)
</span><span class="cx"> 
</span><span class="cx">            Performs a range checked switch on the scrutinee value, using
</span><span class="lines">@@ -3189,9 +3189,9 @@
</span><span class="cx">             int32_t value = JSImmediate::getTruncatedInt32(scrutinee);
</span><span class="cx">             vPC += callFrame-&gt;codeBlock()-&gt;immediateSwitchJumpTables[tableIndex].offsetForValue(value, defaultOffset);
</span><span class="cx">         }
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_switch_char) {
</del><ins>+    DEFINE_OPCODE(op_switch_char) {
</ins><span class="cx">         /* switch_char tableIndex(n) defaultOffset(offset) scrutinee(r)
</span><span class="cx"> 
</span><span class="cx">            Performs a range checked switch on the scrutinee value, using
</span><span class="lines">@@ -3212,9 +3212,9 @@
</span><span class="cx">             else
</span><span class="cx">                 vPC += callFrame-&gt;codeBlock()-&gt;characterSwitchJumpTables[tableIndex].offsetForValue(value-&gt;data()[0], defaultOffset);
</span><span class="cx">         }
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_switch_string) {
</del><ins>+    DEFINE_OPCODE(op_switch_string) {
</ins><span class="cx">         /* switch_string tableIndex(n) defaultOffset(offset) scrutinee(r)
</span><span class="cx"> 
</span><span class="cx">            Performs a sparse hashmap based switch on the value in the scrutinee
</span><span class="lines">@@ -3230,9 +3230,9 @@
</span><span class="cx">             vPC += defaultOffset;
</span><span class="cx">         else 
</span><span class="cx">             vPC += callFrame-&gt;codeBlock()-&gt;stringSwitchJumpTables[tableIndex].offsetForValue(asString(scrutinee)-&gt;value().rep(), defaultOffset);
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_new_func) {
</del><ins>+    DEFINE_OPCODE(op_new_func) {
</ins><span class="cx">         /* new_func dst(r) func(f)
</span><span class="cx"> 
</span><span class="cx">            Constructs a new Function instance from function func and
</span><span class="lines">@@ -3246,9 +3246,9 @@
</span><span class="cx">         callFrame[dst] = callFrame-&gt;codeBlock()-&gt;functions[func]-&gt;makeFunction(callFrame, callFrame-&gt;scopeChain());
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_new_func_exp) {
</del><ins>+    DEFINE_OPCODE(op_new_func_exp) {
</ins><span class="cx">         /* new_func_exp dst(r) func(f)
</span><span class="cx"> 
</span><span class="cx">            Constructs a new Function instance from function func and
</span><span class="lines">@@ -3262,9 +3262,9 @@
</span><span class="cx">         callFrame[dst] = callFrame-&gt;codeBlock()-&gt;functionExpressions[func]-&gt;makeFunction(callFrame, callFrame-&gt;scopeChain());
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_call_eval) {
</del><ins>+    DEFINE_OPCODE(op_call_eval) {
</ins><span class="cx">         /* call_eval dst(r) func(r) argCount(n) registerOffset(n)
</span><span class="cx"> 
</span><span class="cx">            Call a function named &quot;eval&quot; with no explicit &quot;this&quot; value
</span><span class="lines">@@ -3273,7 +3273,7 @@
</span><span class="cx">            that global object's original global eval function, then
</span><span class="cx">            perform the eval operator in local scope (interpreting
</span><span class="cx">            the argument registers as for the &quot;call&quot;
</span><del>-           bytecode). Otherwise, act exactly as the &quot;call&quot; bytecode would.
</del><ins>+           opcode). Otherwise, act exactly as the &quot;call&quot; opcode would.
</ins><span class="cx">          */
</span><span class="cx"> 
</span><span class="cx">         int dst = vPC[1].u.operand;
</span><span class="lines">@@ -3295,7 +3295,7 @@
</span><span class="cx">             callFrame[dst] = result;
</span><span class="cx"> 
</span><span class="cx">             vPC += 5;
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         // We didn't find the blessed version of eval, so process this
</span><span class="lines">@@ -3309,7 +3309,7 @@
</span><span class="cx"> #endif
</span><span class="cx">         // fall through to op_call
</span><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_call) {
</del><ins>+    DEFINE_OPCODE(op_call) {
</ins><span class="cx">         /* call dst(r) func(r) argCount(n) registerOffset(n)
</span><span class="cx"> 
</span><span class="cx">            Perform a function call.
</span><span class="lines">@@ -3347,11 +3347,11 @@
</span><span class="cx">             callFrame-&gt;init(newCodeBlock, vPC + 5, callDataScopeChain, previousCallFrame, dst, argCount, asFunction(v));
</span><span class="cx">             vPC = newCodeBlock-&gt;instructions.begin();
</span><span class="cx"> 
</span><del>-#if ENABLE(BYTECODE_STATS)
-            BytecodeStats::resetLastInstruction();
</del><ins>+#if ENABLE(OPCODE_STATS)
+            OpcodeStats::resetLastInstruction();
</ins><span class="cx"> #endif
</span><span class="cx"> 
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         if (callType == CallTypeHost) {
</span><span class="lines">@@ -3377,7 +3377,7 @@
</span><span class="cx">             callFrame[dst] = returnValue;
</span><span class="cx"> 
</span><span class="cx">             vPC += 5;
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ASSERT(callType == CallTypeNone);
</span><span class="lines">@@ -3385,7 +3385,7 @@
</span><span class="cx">         exceptionValue = createNotAFunctionError(callFrame, v, vPC, callFrame-&gt;codeBlock());
</span><span class="cx">         goto vm_throw;
</span><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_tear_off_activation) {
</del><ins>+    DEFINE_OPCODE(op_tear_off_activation) {
</ins><span class="cx">         /* tear_off_activation activation(r)
</span><span class="cx"> 
</span><span class="cx">            Copy all locals and parameters to new memory allocated on
</span><span class="lines">@@ -3395,7 +3395,7 @@
</span><span class="cx">            this memory for storing the named parameters, but not any
</span><span class="cx">            extra arguments.
</span><span class="cx"> 
</span><del>-           This bytecode should only be used immediately before op_ret.
</del><ins>+           This opcode should only be used immediately before op_ret.
</ins><span class="cx">         */
</span><span class="cx"> 
</span><span class="cx">         int src = (++vPC)-&gt;u.operand;
</span><span class="lines">@@ -3404,9 +3404,9 @@
</span><span class="cx">         asActivation(callFrame[src].getJSValue())-&gt;copyRegisters(callFrame-&gt;optionalCalleeArguments());
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_tear_off_arguments) {
</del><ins>+    DEFINE_OPCODE(op_tear_off_arguments) {
</ins><span class="cx">         /* tear_off_arguments
</span><span class="cx"> 
</span><span class="cx">            Copy all arguments to new memory allocated on the heap,
</span><span class="lines">@@ -3414,9 +3414,9 @@
</span><span class="cx">            future when looking up named parameters, but not any
</span><span class="cx">            extra arguments. If an activation object exists for the
</span><span class="cx">            current function context, then the tear_off_activation
</span><del>-           bytecode should be used instead.
</del><ins>+           opcode should be used instead.
</ins><span class="cx"> 
</span><del>-           This bytecode should only be used immediately before op_ret.
</del><ins>+           This opcode should only be used immediately before op_ret.
</ins><span class="cx">         */
</span><span class="cx"> 
</span><span class="cx">         ASSERT(callFrame-&gt;codeBlock()-&gt;usesArguments &amp;&amp; !callFrame-&gt;codeBlock()-&gt;needsFullScopeChain);
</span><span class="lines">@@ -3424,9 +3424,9 @@
</span><span class="cx">         callFrame-&gt;optionalCalleeArguments()-&gt;copyRegisters();
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_ret) {
</del><ins>+    DEFINE_OPCODE(op_ret) {
</ins><span class="cx">         /* ret result(r)
</span><span class="cx">            
</span><span class="cx">            Return register result as the return value of the current
</span><span class="lines">@@ -3452,16 +3452,16 @@
</span><span class="cx"> 
</span><span class="cx">         callFrame[dst] = returnValue;
</span><span class="cx"> 
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_enter) {
</del><ins>+    DEFINE_OPCODE(op_enter) {
</ins><span class="cx">         /* enter
</span><span class="cx"> 
</span><span class="cx">            Initializes local variables to undefined and fills constant
</span><span class="cx">            registers with their values. If the code block requires an
</span><span class="cx">            activation, enter_with_activation should be used instead.
</span><span class="cx"> 
</span><del>-           This bytecode should only be used at the beginning of a code
</del><ins>+           This opcode should only be used at the beginning of a code
</ins><span class="cx">            block.
</span><span class="cx">         */
</span><span class="cx"> 
</span><span class="lines">@@ -3475,9 +3475,9 @@
</span><span class="cx">             callFrame[i] = codeBlock-&gt;constantRegisters[j];
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_enter_with_activation) {
</del><ins>+    DEFINE_OPCODE(op_enter_with_activation) {
</ins><span class="cx">         /* enter_with_activation dst(r)
</span><span class="cx"> 
</span><span class="cx">            Initializes local variables to undefined, fills constant
</span><span class="lines">@@ -3486,7 +3486,7 @@
</span><span class="cx">            of the scope chain. If the code block does not require an
</span><span class="cx">            activation, enter should be used instead.
</span><span class="cx"> 
</span><del>-           This bytecode should only be used at the beginning of a code
</del><ins>+           This opcode should only be used at the beginning of a code
</ins><span class="cx">            block.
</span><span class="cx">         */
</span><span class="cx"> 
</span><span class="lines">@@ -3505,17 +3505,17 @@
</span><span class="cx">         callFrame-&gt;setScopeChain(callFrame-&gt;scopeChain()-&gt;copy()-&gt;push(activation));
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_convert_this) {
</del><ins>+    DEFINE_OPCODE(op_convert_this) {
</ins><span class="cx">         /* convert_this this(r)
</span><span class="cx"> 
</span><span class="cx">            Takes the value in the 'this' register, converts it to a
</span><span class="cx">            value that is suitable for use as the 'this' value, and
</span><del>-           stores it in the 'this' register. This bytecode is emitted
</del><ins>+           stores it in the 'this' register. This opcode is emitted
</ins><span class="cx">            to avoid doing the conversion in the caller unnecessarily.
</span><span class="cx"> 
</span><del>-           This bytecode should only be used at the beginning of a code
</del><ins>+           This opcode should only be used at the beginning of a code
</ins><span class="cx">            block.
</span><span class="cx">         */
</span><span class="cx"> 
</span><span class="lines">@@ -3525,16 +3525,16 @@
</span><span class="cx">             callFrame[thisRegister] = thisVal-&gt;toThisObject(callFrame);
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_create_arguments) {
</del><ins>+    DEFINE_OPCODE(op_create_arguments) {
</ins><span class="cx">         /* create_arguments
</span><span class="cx"> 
</span><span class="cx">            Creates the 'arguments' object and places it in both the
</span><span class="cx">            'arguments' call frame slot and the local 'arguments'
</span><span class="cx">            register.
</span><span class="cx"> 
</span><del>-           This bytecode should only be used at the beginning of a code
</del><ins>+           This opcode should only be used at the beginning of a code
</ins><span class="cx">            block.
</span><span class="cx">         */
</span><span class="cx"> 
</span><span class="lines">@@ -3543,17 +3543,17 @@
</span><span class="cx">         callFrame[RegisterFile::ArgumentsRegister] = arguments;
</span><span class="cx">         
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_construct) {
</del><ins>+    DEFINE_OPCODE(op_construct) {
</ins><span class="cx">         /* construct dst(r) func(r) argCount(n) registerOffset(n) proto(r) thisRegister(r)
</span><span class="cx"> 
</span><span class="cx">            Invoke register &quot;func&quot; as a constructor. For JS
</span><span class="cx">            functions, the calling convention is exactly as for the
</span><del>-           &quot;call&quot; bytecode, except that the &quot;this&quot; value is a newly
</del><ins>+           &quot;call&quot; opcode, except that the &quot;this&quot; value is a newly
</ins><span class="cx">            created Object. For native constructors, no &quot;this&quot;
</span><span class="cx">            value is passed. In either case, the argCount and registerOffset
</span><del>-           registers are interpreted as for the &quot;call&quot; bytecode.
</del><ins>+           registers are interpreted as for the &quot;call&quot; opcode.
</ins><span class="cx"> 
</span><span class="cx">            Register proto must contain the prototype property of
</span><span class="cx">            register func. This is to enable polymorphic inline
</span><span class="lines">@@ -3599,11 +3599,11 @@
</span><span class="cx">             callFrame-&gt;init(newCodeBlock, vPC + 7, callDataScopeChain, previousCallFrame, dst, argCount, asFunction(v));
</span><span class="cx">             vPC = newCodeBlock-&gt;instructions.begin();
</span><span class="cx"> 
</span><del>-#if ENABLE(BYTECODE_STATS)
-            BytecodeStats::resetLastInstruction();
</del><ins>+#if ENABLE(OPCODE_STATS)
+            OpcodeStats::resetLastInstruction();
</ins><span class="cx"> #endif
</span><span class="cx"> 
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         if (constructType == ConstructTypeHost) {
</span><span class="lines">@@ -3622,7 +3622,7 @@
</span><span class="cx">             callFrame[dst] = returnValue;
</span><span class="cx"> 
</span><span class="cx">             vPC += 7;
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ASSERT(constructType == ConstructTypeNone);
</span><span class="lines">@@ -3630,7 +3630,7 @@
</span><span class="cx">         exceptionValue = createNotAConstructorError(callFrame, v, vPC, callFrame-&gt;codeBlock());
</span><span class="cx">         goto vm_throw;
</span><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_construct_verify) {
</del><ins>+    DEFINE_OPCODE(op_construct_verify) {
</ins><span class="cx">         /* construct_verify dst(r) override(r)
</span><span class="cx"> 
</span><span class="cx">            Verifies that register dst holds an object. If not, moves
</span><span class="lines">@@ -3640,16 +3640,16 @@
</span><span class="cx">         int dst = vPC[1].u.operand;;
</span><span class="cx">         if (LIKELY(callFrame[dst].jsValue(callFrame)-&gt;isObject())) {
</span><span class="cx">             vPC += 3;
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         int override = vPC[2].u.operand;
</span><span class="cx">         callFrame[dst] = callFrame[override];
</span><span class="cx"> 
</span><span class="cx">         vPC += 3;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_push_scope) {
</del><ins>+    DEFINE_OPCODE(op_push_scope) {
</ins><span class="cx">         /* push_scope scope(r)
</span><span class="cx"> 
</span><span class="cx">            Converts register scope to object, and pushes it onto the top
</span><span class="lines">@@ -3663,9 +3663,9 @@
</span><span class="cx">         callFrame-&gt;setScopeChain(callFrame-&gt;scopeChain()-&gt;push(o));
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_pop_scope) {
</del><ins>+    DEFINE_OPCODE(op_pop_scope) {
</ins><span class="cx">         /* pop_scope
</span><span class="cx"> 
</span><span class="cx">            Removes the top item from the current scope chain.
</span><span class="lines">@@ -3673,9 +3673,9 @@
</span><span class="cx">         callFrame-&gt;setScopeChain(callFrame-&gt;scopeChain()-&gt;pop());
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_get_pnames) {
</del><ins>+    DEFINE_OPCODE(op_get_pnames) {
</ins><span class="cx">         /* get_pnames dst(r) base(r)
</span><span class="cx"> 
</span><span class="cx">            Creates a property name list for register base and puts it
</span><span class="lines">@@ -3688,9 +3688,9 @@
</span><span class="cx"> 
</span><span class="cx">         callFrame[dst] = JSPropertyNameIterator::create(callFrame, callFrame[base].jsValue(callFrame));
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_next_pname) {
</del><ins>+    DEFINE_OPCODE(op_next_pname) {
</ins><span class="cx">         /* next_pname dst(r) iter(r) target(offset)
</span><span class="cx"> 
</span><span class="cx">            Tries to copies the next name from property name list in
</span><span class="lines">@@ -3708,14 +3708,14 @@
</span><span class="cx">             CHECK_FOR_TIMEOUT();
</span><span class="cx">             callFrame[dst] = temp;
</span><span class="cx">             vPC += target;
</span><del>-            NEXT_BYTECODE;
</del><ins>+            NEXT_INSTRUCTION;
</ins><span class="cx">         }
</span><span class="cx">         it-&gt;invalidate();
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_jmp_scopes) {
</del><ins>+    DEFINE_OPCODE(op_jmp_scopes) {
</ins><span class="cx">         /* jmp_scopes count(n) target(offset)
</span><span class="cx"> 
</span><span class="cx">            Removes the a number of items from the current scope chain
</span><span class="lines">@@ -3731,13 +3731,13 @@
</span><span class="cx">         callFrame-&gt;setScopeChain(tmp);
</span><span class="cx"> 
</span><span class="cx">         vPC += target;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><span class="cx"> #if HAVE(COMPUTED_GOTO)
</span><span class="cx">     // Appease GCC
</span><span class="cx">     goto *(&amp;&amp;skip_new_scope);
</span><span class="cx"> #endif
</span><del>-    BEGIN_BYTECODE(op_push_new_scope) {
</del><ins>+    DEFINE_OPCODE(op_push_new_scope) {
</ins><span class="cx">         /* new_scope dst(r) property(id) value(r)
</span><span class="cx">          
</span><span class="cx">            Constructs a new StaticScopeObject with property set to value.  That scope
</span><span class="lines">@@ -3747,12 +3747,12 @@
</span><span class="cx">         callFrame-&gt;setScopeChain(createExceptionScope(callFrame, vPC));
</span><span class="cx"> 
</span><span class="cx">         vPC += 4;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><span class="cx"> #if HAVE(COMPUTED_GOTO)
</span><span class="cx">     skip_new_scope:
</span><span class="cx"> #endif
</span><del>-    BEGIN_BYTECODE(op_catch) {
</del><ins>+    DEFINE_OPCODE(op_catch) {
</ins><span class="cx">         /* catch ex(r)
</span><span class="cx"> 
</span><span class="cx">            Retrieves the VMs current exception and puts it in register
</span><span class="lines">@@ -3766,9 +3766,9 @@
</span><span class="cx">         exceptionValue = noValue();
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_throw) {
</del><ins>+    DEFINE_OPCODE(op_throw) {
</ins><span class="cx">         /* throw ex(r)
</span><span class="cx"> 
</span><span class="cx">            Throws register ex as an exception. This involves three
</span><span class="lines">@@ -3798,9 +3798,9 @@
</span><span class="cx"> #endif
</span><span class="cx"> 
</span><span class="cx">         vPC = handlerVPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_unexpected_load) {
</del><ins>+    DEFINE_OPCODE(op_unexpected_load) {
</ins><span class="cx">         /* unexpected_load load dst(r) src(k)
</span><span class="cx"> 
</span><span class="cx">            Copies constant src to register dst.
</span><span class="lines">@@ -3810,9 +3810,9 @@
</span><span class="cx">         callFrame[dst] = callFrame-&gt;codeBlock()-&gt;unexpectedConstants[src];
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_new_error) {
</del><ins>+    DEFINE_OPCODE(op_new_error) {
</ins><span class="cx">         /* new_error dst(r) type(n) message(k)
</span><span class="cx"> 
</span><span class="cx">            Constructs a new Error instance using the original
</span><span class="lines">@@ -3828,9 +3828,9 @@
</span><span class="cx">         callFrame[dst] = Error::create(callFrame, (ErrorType)type, codeBlock-&gt;unexpectedConstants[message]-&gt;toString(callFrame), codeBlock-&gt;lineNumberForVPC(vPC), codeBlock-&gt;ownerNode-&gt;sourceID(), codeBlock-&gt;ownerNode-&gt;sourceURL());
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_end) {
</del><ins>+    DEFINE_OPCODE(op_end) {
</ins><span class="cx">         /* end result(r)
</span><span class="cx">            
</span><span class="cx">            Return register result as the value of a global or eval
</span><span class="lines">@@ -3845,7 +3845,7 @@
</span><span class="cx">         int result = (++vPC)-&gt;u.operand;
</span><span class="cx">         return callFrame[result].jsValue(callFrame);
</span><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_put_getter) {
</del><ins>+    DEFINE_OPCODE(op_put_getter) {
</ins><span class="cx">         /* put_getter base(r) property(id) function(r)
</span><span class="cx"> 
</span><span class="cx">            Sets register function on register base as the getter named
</span><span class="lines">@@ -3853,7 +3853,7 @@
</span><span class="cx">            objects as this op should only be used for getters defined
</span><span class="cx">            in object literal form.
</span><span class="cx"> 
</span><del>-           Unlike many bytecodes, this one does not write any output to
</del><ins>+           Unlike many opcodes, this one does not write any output to
</ins><span class="cx">            the register file.
</span><span class="cx">         */
</span><span class="cx">         int base = (++vPC)-&gt;u.operand;
</span><span class="lines">@@ -3867,9 +3867,9 @@
</span><span class="cx">         baseObj-&gt;defineGetter(callFrame, ident, asObject(callFrame[function].jsValue(callFrame)));
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_put_setter) {
</del><ins>+    DEFINE_OPCODE(op_put_setter) {
</ins><span class="cx">         /* put_setter base(r) property(id) function(r)
</span><span class="cx"> 
</span><span class="cx">            Sets register function on register base as the setter named
</span><span class="lines">@@ -3877,7 +3877,7 @@
</span><span class="cx">            objects as this op should only be used for setters defined
</span><span class="cx">            in object literal form.
</span><span class="cx"> 
</span><del>-           Unlike many bytecodes, this one does not write any output to
</del><ins>+           Unlike many opcodes, this one does not write any output to
</ins><span class="cx">            the register file.
</span><span class="cx">         */
</span><span class="cx">         int base = (++vPC)-&gt;u.operand;
</span><span class="lines">@@ -3891,9 +3891,9 @@
</span><span class="cx">         baseObj-&gt;defineSetter(callFrame, ident, asObject(callFrame[function].jsValue(callFrame)));
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_jsr) {
</del><ins>+    DEFINE_OPCODE(op_jsr) {
</ins><span class="cx">         /* jsr retAddrDst(r) target(offset)
</span><span class="cx"> 
</span><span class="cx">            Places the address of the next instruction into the retAddrDst
</span><span class="lines">@@ -3904,9 +3904,9 @@
</span><span class="cx">         callFrame[retAddrDst] = vPC + 1;
</span><span class="cx"> 
</span><span class="cx">         vPC += target;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_sret) {
</del><ins>+    DEFINE_OPCODE(op_sret) {
</ins><span class="cx">         /* sret retAddrSrc(r)
</span><span class="cx"> 
</span><span class="cx">          Jumps to the address stored in the retAddrSrc register. This
</span><span class="lines">@@ -3915,12 +3915,12 @@
</span><span class="cx">         */
</span><span class="cx">         int retAddrSrc = (++vPC)-&gt;u.operand;
</span><span class="cx">         vPC = callFrame[retAddrSrc].vPC();
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_debug) {
</del><ins>+    DEFINE_OPCODE(op_debug) {
</ins><span class="cx">         /* debug debugHookID(n) firstLine(n) lastLine(n)
</span><span class="cx"> 
</span><del>-         Notifies the debugger of the current state of execution. This bytecode
</del><ins>+         Notifies the debugger of the current state of execution. This opcode
</ins><span class="cx">          is only generated while the debugger is attached.
</span><span class="cx">         */
</span><span class="cx">         int debugHookID = (++vPC)-&gt;u.operand;
</span><span class="lines">@@ -3930,12 +3930,12 @@
</span><span class="cx">         debug(callFrame, static_cast&lt;DebugHookID&gt;(debugHookID), firstLine, lastLine);
</span><span class="cx"> 
</span><span class="cx">         ++vPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_profile_will_call) {
</del><ins>+    DEFINE_OPCODE(op_profile_will_call) {
</ins><span class="cx">         /* op_profile_will_call function(r)
</span><span class="cx"> 
</span><del>-         Notifies the profiler of the beginning of a function call. This bytecode
</del><ins>+         Notifies the profiler of the beginning of a function call. This opcode
</ins><span class="cx">          is only generated if developer tools are enabled.
</span><span class="cx">         */
</span><span class="cx">         int function = vPC[1].u.operand;
</span><span class="lines">@@ -3944,12 +3944,12 @@
</span><span class="cx">             (*enabledProfilerReference)-&gt;willExecute(callFrame, callFrame[function].jsValue(callFrame));
</span><span class="cx"> 
</span><span class="cx">         vPC += 2;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><del>-    BEGIN_BYTECODE(op_profile_did_call) {
</del><ins>+    DEFINE_OPCODE(op_profile_did_call) {
</ins><span class="cx">         /* op_profile_did_call function(r)
</span><span class="cx"> 
</span><del>-         Notifies the profiler of the end of a function call. This bytecode
</del><ins>+         Notifies the profiler of the end of a function call. This opcode
</ins><span class="cx">          is only generated if developer tools are enabled.
</span><span class="cx">         */
</span><span class="cx">         int function = vPC[1].u.operand;
</span><span class="lines">@@ -3958,7 +3958,7 @@
</span><span class="cx">             (*enabledProfilerReference)-&gt;didExecute(callFrame, callFrame[function].jsValue(callFrame));
</span><span class="cx"> 
</span><span class="cx">         vPC += 2;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><span class="cx">     vm_throw: {
</span><span class="cx">         globalData-&gt;exception = noValue();
</span><span class="lines">@@ -3973,14 +3973,14 @@
</span><span class="cx">             return jsNull();
</span><span class="cx">         }
</span><span class="cx">         vPC = handlerVPC;
</span><del>-        NEXT_BYTECODE;
</del><ins>+        NEXT_INSTRUCTION;
</ins><span class="cx">     }
</span><span class="cx">     }
</span><span class="cx"> #if !HAVE(COMPUTED_GOTO)
</span><span class="cx">     } // iterator loop ends
</span><span class="cx"> #endif
</span><del>-    #undef NEXT_BYTECODE
-    #undef BEGIN_BYTECODE
</del><ins>+    #undef NEXT_INSTRUCTION
+    #undef DEFINE_OPCODE
</ins><span class="cx">     #undef VM_CHECK_EXCEPTION
</span><span class="cx">     #undef CHECK_FOR_TIMEOUT
</span><span class="cx"> }
</span><span class="lines">@@ -4095,7 +4095,7 @@
</span><span class="cx"> 
</span><span class="cx">     // StructureID transition, cache transition info
</span><span class="cx">     if (slot.type() == PutPropertySlot::NewProperty) {
</span><del>-        vPC[0] = getBytecode(op_put_by_id_transition);
</del><ins>+        vPC[0] = getOpcode(op_put_by_id_transition);
</ins><span class="cx">         vPC[4] = structureID-&gt;previousID();
</span><span class="cx">         vPC[5] = structureID;
</span><span class="cx">         StructureIDChain* chain = structureID-&gt;cachedPrototypeChain();
</span><span class="lines">@@ -4103,7 +4103,7 @@
</span><span class="cx">             chain = cachePrototypeChain(callFrame, structureID);
</span><span class="cx">             if (!chain) {
</span><span class="cx">                 // This happens if someone has manually inserted null into the prototype chain
</span><del>-                vPC[0] = getBytecode(op_put_by_id_generic);
</del><ins>+                vPC[0] = getOpcode(op_put_by_id_generic);
</ins><span class="cx">                 return;
</span><span class="cx">             }
</span><span class="cx">         }
</span><span class="lines">@@ -4114,7 +4114,7 @@
</span><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    vPC[0] = getBytecode(op_put_by_id_replace);
</del><ins>+    vPC[0] = getOpcode(op_put_by_id_replace);
</ins><span class="cx">     vPC[4] = structureID;
</span><span class="cx">     vPC[5] = slot.cachedOffset();
</span><span class="cx">     codeBlock-&gt;refStructureIDs(vPC);
</span><span class="lines">@@ -4177,7 +4177,7 @@
</span><span class="cx"> 
</span><span class="cx">     if (slot.slotBase() == baseValue) {
</span><span class="cx">         // set this up, so derefStructureIDs can do it's job.
</span><del>-        vPC[0] = getBytecode(op_get_by_id_self);
</del><ins>+        vPC[0] = getOpcode(op_get_by_id_self);
</ins><span class="cx">         vPC[4] = structureID;
</span><span class="cx">         vPC[5] = slot.cachedOffset();
</span><span class="cx">         codeBlock-&gt;refStructureIDs(vPC);
</span><span class="lines">@@ -4203,7 +4203,7 @@
</span><span class="cx">             asObject(baseValue)-&gt;structureID()-&gt;setCachedPrototypeChain(0);
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        vPC[0] = getBytecode(op_get_by_id_proto);
</del><ins>+        vPC[0] = getOpcode(op_get_by_id_proto);
</ins><span class="cx">         vPC[4] = structureID;
</span><span class="cx">         vPC[5] = slotBaseObject-&gt;structureID();
</span><span class="cx">         vPC[6] = slot.cachedOffset();
</span><span class="lines">@@ -4222,7 +4222,7 @@
</span><span class="cx">         // must be a proxy for another object.
</span><span class="cx"> 
</span><span class="cx">         if (v-&gt;isNull()) {
</span><del>-            vPC[0] = getBytecode(op_get_by_id_generic);
</del><ins>+            vPC[0] = getOpcode(op_get_by_id_generic);
</ins><span class="cx">             return;
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="lines">@@ -4244,7 +4244,7 @@
</span><span class="cx">         chain = cachePrototypeChain(callFrame, structureID);
</span><span class="cx"> 
</span><span class="cx">     ASSERT(chain);
</span><del>-    vPC[0] = getBytecode(op_get_by_id_chain);
</del><ins>+    vPC[0] = getOpcode(op_get_by_id_chain);
</ins><span class="cx">     vPC[4] = structureID;
</span><span class="cx">     vPC[5] = chain;
</span><span class="cx">     vPC[6] = count;
</span></span></pre></div>
<a id="trunkJavaScriptCoreVMMachineh"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/VM/Machine.h (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/VM/Machine.h        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/VM/Machine.h        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -111,26 +111,26 @@
</span><span class="cx">         
</span><span class="cx">         RegisterFile&amp; registerFile() { return m_registerFile; }
</span><span class="cx">         
</span><del>-        Bytecode getBytecode(BytecodeID id)
</del><ins>+        Opcode getOpcode(OpcodeID id)
</ins><span class="cx">         {
</span><span class="cx">             #if HAVE(COMPUTED_GOTO)
</span><del>-                return m_bytecodeTable[id];
</del><ins>+                return m_opcodeTable[id];
</ins><span class="cx">             #else
</span><span class="cx">                 return id;
</span><span class="cx">             #endif
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        BytecodeID getBytecodeID(Bytecode bytecode)
</del><ins>+        OpcodeID getOpcodeID(Opcode opcode)
</ins><span class="cx">         {
</span><span class="cx">             #if HAVE(COMPUTED_GOTO)
</span><del>-                ASSERT(isBytecode(bytecode));
-                return m_bytecodeIDTable.get(bytecode);
</del><ins>+                ASSERT(isOpcode(opcode));
+                return m_opcodeIDTable.get(opcode);
</ins><span class="cx">             #else
</span><del>-                return bytecode;
</del><ins>+                return opcode;
</ins><span class="cx">             #endif
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        bool isBytecode(Bytecode bytecode);
</del><ins>+        bool isOpcode(Opcode);
</ins><span class="cx">         
</span><span class="cx">         JSValue* execute(ProgramNode*, CallFrame*, ScopeChainNode*, JSObject* thisObj, JSValue** exception);
</span><span class="cx">         JSValue* execute(FunctionBodyNode*, CallFrame*, JSFunction*, JSObject* thisObj, const ArgList&amp; args, ScopeChainNode*, JSValue** exception);
</span><span class="lines">@@ -318,7 +318,7 @@
</span><span class="cx">         void tryCachePutByID(CallFrame*, CodeBlock*, Instruction*, JSValue* baseValue, const PutPropertySlot&amp;);
</span><span class="cx">         void uncachePutByID(CodeBlock*, Instruction* vPC);
</span><span class="cx">         
</span><del>-        bool isCallBytecode(Bytecode bytecode) { return bytecode == getBytecode(op_call) || bytecode == getBytecode(op_construct) || bytecode == getBytecode(op_call_eval); }
</del><ins>+        bool isCallBytecode(Opcode opcode) { return opcode == getOpcode(op_call) || opcode == getOpcode(op_construct) || opcode == getOpcode(op_call_eval); }
</ins><span class="cx"> 
</span><span class="cx"> #if ENABLE(CTI)
</span><span class="cx">         static void throwStackOverflowPreviousFrame(CallFrame**, JSGlobalData*, void*&amp; returnAddress);
</span><span class="lines">@@ -355,8 +355,8 @@
</span><span class="cx">         void* m_jsFunctionVptr;
</span><span class="cx"> 
</span><span class="cx"> #if HAVE(COMPUTED_GOTO)
</span><del>-        Bytecode m_bytecodeTable[numBytecodeIDs]; // Maps BytecodeID =&gt; Bytecode for compiling
-        HashMap&lt;Bytecode, BytecodeID&gt; m_bytecodeIDTable; // Maps Bytecode =&gt; BytecodeID for decompiling
</del><ins>+        Opcode m_opcodeTable[numOpcodeIDs]; // Maps OpcodeID =&gt; Opcode for compiling
+        HashMap&lt;Opcode, OpcodeID&gt; m_opcodeIDTable; // Maps Opcode =&gt; OpcodeID for decompiling
</ins><span class="cx"> #endif
</span><span class="cx">     };
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkJavaScriptCoreVMOpcodecpp"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/VM/Opcode.cpp (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/VM/Opcode.cpp        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/VM/Opcode.cpp        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -34,38 +34,38 @@
</span><span class="cx"> 
</span><span class="cx"> namespace JSC {
</span><span class="cx"> 
</span><del>-#if ENABLE(BYTECODE_SAMPLING) || ENABLE(CODEBLOCK_SAMPLING) || ENABLE(BYTECODE_STATS)
</del><ins>+#if ENABLE(OPCODE_SAMPLING) || ENABLE(CODEBLOCK_SAMPLING) || ENABLE(OPCODE_STATS)
</ins><span class="cx"> 
</span><del>-const char* const bytecodeNames[] = {
-#define BYTECODE_NAME_ENTRY(bytecode) #bytecode,
-    FOR_EACH_BYTECODE_ID(BYTECODE_NAME_ENTRY)
-#undef BYTECODE_NAME_ENTRY
</del><ins>+const char* const opcodeNames[] = {
+#define OPCODE_NAME_ENTRY(opcode) #opcode,
+    FOR_EACH_OPCODE_ID(OPCODE_NAME_ENTRY)
+#undef OPCODE_NAME_ENTRY
</ins><span class="cx"> };
</span><span class="cx"> 
</span><span class="cx"> #endif
</span><span class="cx"> 
</span><del>-#if ENABLE(BYTECODE_STATS)
</del><ins>+#if ENABLE(OPCODE_STATS)
</ins><span class="cx"> 
</span><del>-long long BytecodeStats::bytecodeCounts[numBytecodeIDs];
-long long BytecodeStats::bytecodePairCounts[numBytecodeIDs][numBytecodeIDs];
-int BytecodeStats::lastBytecode = -1;
</del><ins>+long long OpcodeStats::opcodeCounts[numOpcodeIDs];
+long long OpcodeStats::opcodePairCounts[numOpcodeIDs][numOpcodeIDs];
+int OpcodeStats::lastOpcode = -1;
</ins><span class="cx"> 
</span><del>-static BytecodeStats logger;
</del><ins>+static OpcodeStats logger;
</ins><span class="cx"> 
</span><del>-BytecodeStats::BytecodeStats()
</del><ins>+OpcodeStats::OpcodeStats()
</ins><span class="cx"> {
</span><del>-    for (int i = 0; i &lt; numBytecodeIDs; ++i)
-        bytecodeCounts[i] = 0;
</del><ins>+    for (int i = 0; i &lt; numOpcodeIDs; ++i)
+        opcodeCounts[i] = 0;
</ins><span class="cx">     
</span><del>-    for (int i = 0; i &lt; numBytecodeIDs; ++i)
-        for (int j = 0; j &lt; numBytecodeIDs; ++j)
-            bytecodePairCounts[i][j] = 0;
</del><ins>+    for (int i = 0; i &lt; numOpcodeIDs; ++i)
+        for (int j = 0; j &lt; numOpcodeIDs; ++j)
+            opcodePairCounts[i][j] = 0;
</ins><span class="cx"> }
</span><span class="cx"> 
</span><del>-static int compareBytecodeIndices(const void* left, const void* right)
</del><ins>+static int compareOpcodeIndices(const void* left, const void* right)
</ins><span class="cx"> {
</span><del>-    long long leftValue = BytecodeStats::bytecodeCounts[*(int*) left];
-    long long rightValue = BytecodeStats::bytecodeCounts[*(int*) right];
</del><ins>+    long long leftValue = OpcodeStats::opcodeCounts[*(int*) left];
+    long long rightValue = OpcodeStats::opcodeCounts[*(int*) right];
</ins><span class="cx">     
</span><span class="cx">     if (leftValue &lt; rightValue)
</span><span class="cx">         return 1;
</span><span class="lines">@@ -75,12 +75,12 @@
</span><span class="cx">         return 0;
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-static int compareBytecodePairIndices(const void* left, const void* right)
</del><ins>+static int compareOpcodePairIndices(const void* left, const void* right)
</ins><span class="cx"> {
</span><span class="cx">     pair&lt;int, int&gt; leftPair = *(pair&lt;int, int&gt;*) left;
</span><del>-    long long leftValue = BytecodeStats::bytecodePairCounts[leftPair.first][leftPair.second];
</del><ins>+    long long leftValue = OpcodeStats::opcodePairCounts[leftPair.first][leftPair.second];
</ins><span class="cx">     pair&lt;int, int&gt; rightPair = *(pair&lt;int, int&gt;*) right;
</span><del>-    long long rightValue = BytecodeStats::bytecodePairCounts[rightPair.first][rightPair.second];
</del><ins>+    long long rightValue = OpcodeStats::opcodePairCounts[rightPair.first][rightPair.second];
</ins><span class="cx">     
</span><span class="cx">     if (leftValue &lt; rightValue)
</span><span class="cx">         return 1;
</span><span class="lines">@@ -90,95 +90,95 @@
</span><span class="cx">         return 0;
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-BytecodeStats::~BytecodeStats()
</del><ins>+OpcodeStats::~OpcodeStats()
</ins><span class="cx"> {
</span><span class="cx">     long long totalInstructions = 0;
</span><del>-    for (int i = 0; i &lt; numBytecodeIDs; ++i)
-        totalInstructions += bytecodeCounts[i];
</del><ins>+    for (int i = 0; i &lt; numOpcodeIDs; ++i)
+        totalInstructions += opcodeCounts[i];
</ins><span class="cx">     
</span><span class="cx">     long long totalInstructionPairs = 0;
</span><del>-    for (int i = 0; i &lt; numBytecodeIDs; ++i)
-        for (int j = 0; j &lt; numBytecodeIDs; ++j)
-            totalInstructionPairs += bytecodePairCounts[i][j];
</del><ins>+    for (int i = 0; i &lt; numOpcodeIDs; ++i)
+        for (int j = 0; j &lt; numOpcodeIDs; ++j)
+            totalInstructionPairs += opcodePairCounts[i][j];
</ins><span class="cx"> 
</span><del>-    int sortedIndices[numBytecodeIDs];    
-    for (int i = 0; i &lt; numBytecodeIDs; ++i)
</del><ins>+    int sortedIndices[numOpcodeIDs];    
+    for (int i = 0; i &lt; numOpcodeIDs; ++i)
</ins><span class="cx">         sortedIndices[i] = i;
</span><del>-    qsort(sortedIndices, numBytecodeIDs, sizeof(int), compareBytecodeIndices);
</del><ins>+    qsort(sortedIndices, numOpcodeIDs, sizeof(int), compareOpcodeIndices);
</ins><span class="cx">     
</span><del>-    pair&lt;int, int&gt; sortedPairIndices[numBytecodeIDs * numBytecodeIDs];
</del><ins>+    pair&lt;int, int&gt; sortedPairIndices[numOpcodeIDs * numOpcodeIDs];
</ins><span class="cx">     pair&lt;int, int&gt;* currentPairIndex = sortedPairIndices;
</span><del>-    for (int i = 0; i &lt; numBytecodeIDs; ++i)
-        for (int j = 0; j &lt; numBytecodeIDs; ++j)
</del><ins>+    for (int i = 0; i &lt; numOpcodeIDs; ++i)
+        for (int j = 0; j &lt; numOpcodeIDs; ++j)
</ins><span class="cx">             *(currentPairIndex++) = make_pair(i, j);
</span><del>-    qsort(sortedPairIndices, numBytecodeIDs * numBytecodeIDs, sizeof(pair&lt;int, int&gt;), compareBytecodePairIndices);
</del><ins>+    qsort(sortedPairIndices, numOpcodeIDs * numOpcodeIDs, sizeof(pair&lt;int, int&gt;), compareOpcodePairIndices);
</ins><span class="cx">     
</span><del>-    printf(&quot;\nExecuted bytecode statistics\n&quot;); 
</del><ins>+    printf(&quot;\nExecuted opcode statistics\n&quot;); 
</ins><span class="cx">     
</span><span class="cx">     printf(&quot;Total instructions executed: %lld\n\n&quot;, totalInstructions);
</span><span class="cx"> 
</span><del>-    printf(&quot;All bytecodes by frequency:\n\n&quot;);
</del><ins>+    printf(&quot;All opcodes by frequency:\n\n&quot;);
</ins><span class="cx"> 
</span><del>-    for (int i = 0; i &lt; numBytecodeIDs; ++i) {
</del><ins>+    for (int i = 0; i &lt; numOpcodeIDs; ++i) {
</ins><span class="cx">         int index = sortedIndices[i];
</span><del>-        printf(&quot;%s:%s %lld - %.2f%%\n&quot;, bytecodeNames[index], padBytecodeName((BytecodeID)index, 28), bytecodeCounts[index], ((double) bytecodeCounts[index]) / ((double) totalInstructions) * 100.0);    
</del><ins>+        printf(&quot;%s:%s %lld - %.2f%%\n&quot;, opcodeNames[index], padOpcodeName((OpcodeID)index, 28), opcodeCounts[index], ((double) opcodeCounts[index]) / ((double) totalInstructions) * 100.0);    
</ins><span class="cx">     }
</span><span class="cx">     
</span><span class="cx">     printf(&quot;\n&quot;);
</span><del>-    printf(&quot;2-bytecode sequences by frequency: %lld\n\n&quot;, totalInstructions);
</del><ins>+    printf(&quot;2-opcode sequences by frequency: %lld\n\n&quot;, totalInstructions);
</ins><span class="cx">     
</span><del>-    for (int i = 0; i &lt; numBytecodeIDs * numBytecodeIDs; ++i) {
</del><ins>+    for (int i = 0; i &lt; numOpcodeIDs * numOpcodeIDs; ++i) {
</ins><span class="cx">         pair&lt;int, int&gt; indexPair = sortedPairIndices[i];
</span><del>-        long long count = bytecodePairCounts[indexPair.first][indexPair.second];
</del><ins>+        long long count = opcodePairCounts[indexPair.first][indexPair.second];
</ins><span class="cx">         
</span><span class="cx">         if (!count)
</span><span class="cx">             break;
</span><span class="cx">         
</span><del>-        printf(&quot;%s%s %s:%s %lld %.2f%%\n&quot;, bytecodeNames[indexPair.first], padBytecodeName((BytecodeID)indexPair.first, 28), bytecodeNames[indexPair.second], padBytecodeName((BytecodeID)indexPair.second, 28), count, ((double) count) / ((double) totalInstructionPairs) * 100.0);
</del><ins>+        printf(&quot;%s%s %s:%s %lld %.2f%%\n&quot;, opcodeNames[indexPair.first], padOpcodeName((OpcodeID)indexPair.first, 28), opcodeNames[indexPair.second], padOpcodeName((OpcodeID)indexPair.second, 28), count, ((double) count) / ((double) totalInstructionPairs) * 100.0);
</ins><span class="cx">     }
</span><span class="cx">     
</span><span class="cx">     printf(&quot;\n&quot;);
</span><del>-    printf(&quot;Most common bytecodes and sequences:\n&quot;);
</del><ins>+    printf(&quot;Most common opcodes and sequences:\n&quot;);
</ins><span class="cx"> 
</span><del>-    for (int i = 0; i &lt; numBytecodeIDs; ++i) {
</del><ins>+    for (int i = 0; i &lt; numOpcodeIDs; ++i) {
</ins><span class="cx">         int index = sortedIndices[i];
</span><del>-        long long bytecodeCount = bytecodeCounts[index];
-        double bytecodeProportion = ((double) bytecodeCount) / ((double) totalInstructions);
-        if (bytecodeProportion &lt; 0.0001)
</del><ins>+        long long opcodeCount = opcodeCounts[index];
+        double opcodeProportion = ((double) opcodeCount) / ((double) totalInstructions);
+        if (opcodeProportion &lt; 0.0001)
</ins><span class="cx">             break;
</span><del>-        printf(&quot;\n%s:%s %lld - %.2f%%\n&quot;, bytecodeNames[index], padBytecodeName((BytecodeID)index, 28), bytecodeCount, bytecodeProportion * 100.0);
</del><ins>+        printf(&quot;\n%s:%s %lld - %.2f%%\n&quot;, opcodeNames[index], padOpcodeName((OpcodeID)index, 28), opcodeCount, opcodeProportion * 100.0);
</ins><span class="cx"> 
</span><del>-        for (int j = 0; j &lt; numBytecodeIDs * numBytecodeIDs; ++j) {
</del><ins>+        for (int j = 0; j &lt; numOpcodeIDs * numOpcodeIDs; ++j) {
</ins><span class="cx">             pair&lt;int, int&gt; indexPair = sortedPairIndices[j];
</span><del>-            long long pairCount = bytecodePairCounts[indexPair.first][indexPair.second];
</del><ins>+            long long pairCount = opcodePairCounts[indexPair.first][indexPair.second];
</ins><span class="cx">             double pairProportion = ((double) pairCount) / ((double) totalInstructionPairs);
</span><span class="cx">         
</span><del>-            if (!pairCount || pairProportion &lt; 0.0001 || pairProportion &lt; bytecodeProportion / 100)
</del><ins>+            if (!pairCount || pairProportion &lt; 0.0001 || pairProportion &lt; opcodeProportion / 100)
</ins><span class="cx">                 break;
</span><span class="cx"> 
</span><span class="cx">             if (indexPair.first != index &amp;&amp; indexPair.second != index)
</span><span class="cx">                 continue;
</span><span class="cx"> 
</span><del>-            printf(&quot;    %s%s %s:%s %lld - %.2f%%\n&quot;, bytecodeNames[indexPair.first], padBytecodeName((BytecodeID)indexPair.first, 28), bytecodeNames[indexPair.second], padBytecodeName((BytecodeID)indexPair.second, 28), pairCount, pairProportion * 100.0);
</del><ins>+            printf(&quot;    %s%s %s:%s %lld - %.2f%%\n&quot;, opcodeNames[indexPair.first], padOpcodeName((OpcodeID)indexPair.first, 28), opcodeNames[indexPair.second], padOpcodeName((OpcodeID)indexPair.second, 28), pairCount, pairProportion * 100.0);
</ins><span class="cx">         }
</span><span class="cx">         
</span><span class="cx">     }
</span><span class="cx">     printf(&quot;\n&quot;);
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-void BytecodeStats::recordInstruction(int bytecode)
</del><ins>+void OpcodeStats::recordInstruction(int opcode)
</ins><span class="cx"> {
</span><del>-    bytecodeCounts[bytecode]++;
</del><ins>+    opcodeCounts[opcode]++;
</ins><span class="cx">     
</span><del>-    if (lastBytecode != -1)
-        bytecodePairCounts[lastBytecode][bytecode]++;
</del><ins>+    if (lastOpcode != -1)
+        opcodePairCounts[lastOpcode][opcode]++;
</ins><span class="cx">     
</span><del>-    lastBytecode = bytecode;
</del><ins>+    lastOpcode = opcode;
</ins><span class="cx"> }
</span><span class="cx"> 
</span><del>-void BytecodeStats::resetLastInstruction()
</del><ins>+void OpcodeStats::resetLastInstruction()
</ins><span class="cx"> {
</span><del>-    lastBytecode = -1;
</del><ins>+    lastOpcode = -1;
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> #endif
</span></span></pre></div>
<a id="trunkJavaScriptCoreVMOpcodeh"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/VM/Opcode.h (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/VM/Opcode.h        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/VM/Opcode.h        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -27,8 +27,8 @@
</span><span class="cx">  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
</span><span class="cx">  */
</span><span class="cx"> 
</span><del>-#ifndef Bytecodes_h
-#define Bytecodes_h
</del><ins>+#ifndef Opcode_h
+#define Opcode_h
</ins><span class="cx"> 
</span><span class="cx"> #include &lt;algorithm&gt;
</span><span class="cx"> #include &lt;string.h&gt;
</span><span class="lines">@@ -37,7 +37,7 @@
</span><span class="cx"> 
</span><span class="cx"> namespace JSC {
</span><span class="cx"> 
</span><del>-    #define FOR_EACH_BYTECODE_ID(macro) \
</del><ins>+    #define FOR_EACH_OPCODE_ID(macro) \
</ins><span class="cx">         macro(op_enter) \
</span><span class="cx">         macro(op_enter_with_activation) \
</span><span class="cx">         macro(op_create_arguments) \
</span><span class="lines">@@ -162,34 +162,34 @@
</span><span class="cx">         macro(op_profile_will_call) \
</span><span class="cx">         macro(op_profile_did_call) \
</span><span class="cx">         \
</span><del>-        macro(op_end) // end must be the last bytecode in the list
</del><ins>+        macro(op_end) // end must be the last opcode in the list
</ins><span class="cx"> 
</span><del>-    #define BYTECODE_ID_ENUM(bytecode) bytecode,
-        typedef enum { FOR_EACH_BYTECODE_ID(BYTECODE_ID_ENUM) } BytecodeID;
-    #undef BYTECODE_ID_ENUM
</del><ins>+    #define OPCODE_ID_ENUM(opcode) opcode,
+        typedef enum { FOR_EACH_OPCODE_ID(OPCODE_ID_ENUM) } OpcodeID;
+    #undef OPCODE_ID_ENUM
</ins><span class="cx"> 
</span><del>-    const int numBytecodeIDs = op_end + 1;
</del><ins>+    const int numOpcodeIDs = op_end + 1;
</ins><span class="cx"> 
</span><del>-    #define VERIFY_BYTECODE_ID(id) COMPILE_ASSERT(id &lt;= op_end, ASSERT_THAT_JS_BYTECODE_IDS_ARE_VALID);
-        FOR_EACH_BYTECODE_ID(VERIFY_BYTECODE_ID);
-    #undef VERIFY_BYTECODE_ID
</del><ins>+    #define VERIFY_OPCODE_ID(id) COMPILE_ASSERT(id &lt;= op_end, ASSERT_THAT_JS_OPCODE_IDS_ARE_VALID);
+        FOR_EACH_OPCODE_ID(VERIFY_OPCODE_ID);
+    #undef VERIFY_OPCODE_ID
</ins><span class="cx"> 
</span><span class="cx"> #if HAVE(COMPUTED_GOTO)
</span><del>-    typedef void* Bytecode;
</del><ins>+    typedef void* Opcode;
</ins><span class="cx"> #else
</span><del>-    typedef BytecodeID Bytecode;
</del><ins>+    typedef OpcodeID Opcode;
</ins><span class="cx"> #endif
</span><span class="cx"> 
</span><del>-#if ENABLE(BYTECODE_SAMPLING) || ENABLE(CODEBLOCK_SAMPLING) || ENABLE(BYTECODE_STATS)
</del><ins>+#if ENABLE(OPCODE_SAMPLING) || ENABLE(CODEBLOCK_SAMPLING) || ENABLE(OPCODE_STATS)
</ins><span class="cx"> 
</span><span class="cx"> #define PADDING_STRING &quot;                                &quot;
</span><span class="cx"> #define PADDING_STRING_LENGTH static_cast&lt;unsigned&gt;(strlen(PADDING_STRING))
</span><span class="cx"> 
</span><del>-    extern const char* const bytecodeNames[];
</del><ins>+    extern const char* const opcodeNames[];
</ins><span class="cx"> 
</span><del>-    inline const char* padBytecodeName(BytecodeID op, unsigned width)
</del><ins>+    inline const char* padOpcodeName(OpcodeID op, unsigned width)
</ins><span class="cx">     {
</span><del>-        unsigned pad = width - strlen(bytecodeNames[op]);
</del><ins>+        unsigned pad = width - strlen(opcodeNames[op]);
</ins><span class="cx">         pad = std::min(pad, PADDING_STRING_LENGTH);
</span><span class="cx">         return PADDING_STRING + PADDING_STRING_LENGTH - pad;
</span><span class="cx">     }
</span><span class="lines">@@ -199,16 +199,16 @@
</span><span class="cx"> 
</span><span class="cx"> #endif
</span><span class="cx"> 
</span><del>-#if ENABLE(BYTECODE_STATS)
</del><ins>+#if ENABLE(OPCODE_STATS)
</ins><span class="cx"> 
</span><del>-    struct BytecodeStats {
-        BytecodeStats();
-        ~BytecodeStats();
-        static long long bytecodeCounts[numBytecodeIDs];
-        static long long bytecodePairCounts[numBytecodeIDs][numBytecodeIDs];
-        static int lastBytecode;
</del><ins>+    struct OpcodeStats {
+        OpcodeStats();
+        ~OpcodeStats();
+        static long long opcodeCounts[numOpcodeIDs];
+        static long long opcodePairCounts[numOpcodeIDs][numOpcodeIDs];
+        static int lastOpcode;
</ins><span class="cx"> 
</span><del>-        static void recordInstruction(int bytecode);
</del><ins>+        static void recordInstruction(int opcode);
</ins><span class="cx">         static void resetLastInstruction();
</span><span class="cx">     };
</span><span class="cx"> 
</span><span class="lines">@@ -216,4 +216,4 @@
</span><span class="cx"> 
</span><span class="cx"> } // namespace JSC
</span><span class="cx"> 
</span><del>-#endif // Bytecodes_h
</del><ins>+#endif // Opcode_h
</ins></span></pre></div>
<a id="trunkJavaScriptCoreVMSamplingToolcpp"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/VM/SamplingTool.cpp (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/VM/SamplingTool.cpp        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/VM/SamplingTool.cpp        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -54,7 +54,7 @@
</span><span class="cx">     // can fail if we sample mid op_call / op_ret.
</span><span class="cx">     if (offest &lt; m_size) {
</span><span class="cx">         m_samples[offest]++;
</span><del>-        m_bytecodeSampleCount++;
</del><ins>+        m_opcodeSampleCount++;
</ins><span class="cx">     }
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="lines">@@ -94,13 +94,13 @@
</span><span class="cx">             continue;
</span><span class="cx"> 
</span><span class="cx">         if (!sample.inHostFunction()) {
</span><del>-            unsigned bytecodeID = m_interpreter-&gt;getBytecodeID(sample.vPC()[0].u.bytecode);
</del><ins>+            unsigned opcodeID = m_interpreter-&gt;getOpcodeID(sample.vPC()[0].u.opcode);
</ins><span class="cx"> 
</span><del>-            ++m_bytecodeSampleCount;
-            ++m_bytecodeSamples[bytecodeID];
</del><ins>+            ++m_opcodeSampleCount;
+            ++m_opcodeSamples[opcodeID];
</ins><span class="cx"> 
</span><span class="cx">             if (sample.inCTIFunction())
</span><del>-                m_bytecodeSamplesInCTIFunctions[bytecodeID]++;
</del><ins>+                m_opcodeSamplesInCTIFunctions[opcodeID]++;
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx"> #if ENABLE(CODEBLOCK_SAMPLING)
</span><span class="lines">@@ -140,10 +140,10 @@
</span><span class="cx">     waitForThreadCompletion(m_samplingThread, 0);
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx"> 
</span><del>-struct BytecodeSampleInfo {
-    BytecodeID bytecode;
</del><ins>+struct OpcodeSampleInfo {
+    OpcodeID opcode;
</ins><span class="cx">     long long count;
</span><span class="cx">     long long countInCTIFunctions;
</span><span class="cx"> };
</span><span class="lines">@@ -161,10 +161,10 @@
</span><span class="cx">     return (leftLineCount-&gt;line &gt; rightLineCount-&gt;line) ? 1 : (leftLineCount-&gt;line &lt; rightLineCount-&gt;line) ? -1 : 0;
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-static int compareBytecodeIndicesSampling(const void* left, const void* right)
</del><ins>+static int compareOpcodeIndicesSampling(const void* left, const void* right)
</ins><span class="cx"> {
</span><del>-    const BytecodeSampleInfo* leftSampleInfo = reinterpret_cast&lt;const BytecodeSampleInfo*&gt;(left);
-    const BytecodeSampleInfo* rightSampleInfo = reinterpret_cast&lt;const BytecodeSampleInfo*&gt;(right);
</del><ins>+    const OpcodeSampleInfo* leftSampleInfo = reinterpret_cast&lt;const OpcodeSampleInfo*&gt;(left);
+    const OpcodeSampleInfo* rightSampleInfo = reinterpret_cast&lt;const OpcodeSampleInfo*&gt;(right);
</ins><span class="cx"> 
</span><span class="cx">     return (leftSampleInfo-&gt;count &lt; rightSampleInfo-&gt;count) ? 1 : (leftSampleInfo-&gt;count &gt; rightSampleInfo-&gt;count) ? -1 : 0;
</span><span class="cx"> }
</span><span class="lines">@@ -183,48 +183,48 @@
</span><span class="cx">     if (m_sampleCount &lt; 10)
</span><span class="cx">         return;
</span><span class="cx">     
</span><del>-    // (1) Build and sort 'bytecodeSampleInfo' array.
</del><ins>+    // (1) Build and sort 'opcodeSampleInfo' array.
</ins><span class="cx"> 
</span><del>-    BytecodeSampleInfo bytecodeSampleInfo[numBytecodeIDs];
-    for (int i = 0; i &lt; numBytecodeIDs; ++i) {
-        bytecodeSampleInfo[i].bytecode = static_cast&lt;BytecodeID&gt;(i);
-        bytecodeSampleInfo[i].count = m_bytecodeSamples[i];
-        bytecodeSampleInfo[i].countInCTIFunctions = m_bytecodeSamplesInCTIFunctions[i];
</del><ins>+    OpcodeSampleInfo opcodeSampleInfo[numOpcodeIDs];
+    for (int i = 0; i &lt; numOpcodeIDs; ++i) {
+        opcodeSampleInfo[i].opcode = static_cast&lt;OpcodeID&gt;(i);
+        opcodeSampleInfo[i].count = m_opcodeSamples[i];
+        opcodeSampleInfo[i].countInCTIFunctions = m_opcodeSamplesInCTIFunctions[i];
</ins><span class="cx">     }
</span><span class="cx"> 
</span><del>-    qsort(bytecodeSampleInfo, numBytecodeIDs, sizeof(BytecodeSampleInfo), compareBytecodeIndicesSampling);
</del><ins>+    qsort(opcodeSampleInfo, numOpcodeIDs, sizeof(OpcodeSampleInfo), compareOpcodeIndicesSampling);
</ins><span class="cx"> 
</span><del>-    // (2) Print Bytecode sampling results.
</del><ins>+    // (2) Print Opcode sampling results.
</ins><span class="cx"> 
</span><span class="cx">     printf(&quot;\nBytecode samples [*]\n&quot;);
</span><span class="cx">     printf(&quot;                             sample   %% of       %% of     |   cti     cti %%\n&quot;);
</span><del>-    printf(&quot;bytecode                       count     VM        total    |  count   of self\n&quot;);
</del><ins>+    printf(&quot;opcode                       count     VM        total    |  count   of self\n&quot;);
</ins><span class="cx">     printf(&quot;-------------------------------------------------------   |  ----------------\n&quot;);
</span><span class="cx"> 
</span><del>-    for (int i = 0; i &lt; numBytecodeIDs; ++i) {
-        long long count = bytecodeSampleInfo[i].count;
</del><ins>+    for (int i = 0; i &lt; numOpcodeIDs; ++i) {
+        long long count = opcodeSampleInfo[i].count;
</ins><span class="cx">         if (!count)
</span><span class="cx">             continue;
</span><span class="cx"> 
</span><del>-        BytecodeID bytecode = bytecodeSampleInfo[i].bytecode;
</del><ins>+        OpcodeID opcodeID = opcodeSampleInfo[i].opcode;
</ins><span class="cx">         
</span><del>-        const char* bytecodeName = bytecodeNames[bytecode];
-        const char* bytecodePadding = padBytecodeName(bytecode, 28);
-        double percentOfVM = (static_cast&lt;double&gt;(count) * 100) / m_bytecodeSampleCount;
</del><ins>+        const char* opcodeName = opcodeNames[opcodeID];
+        const char* opcodePadding = padOpcodeName(opcodeID, 28);
+        double percentOfVM = (static_cast&lt;double&gt;(count) * 100) / m_opcodeSampleCount;
</ins><span class="cx">         double percentOfTotal = (static_cast&lt;double&gt;(count) * 100) / m_sampleCount;
</span><del>-        long long countInCTIFunctions = bytecodeSampleInfo[i].countInCTIFunctions;
</del><ins>+        long long countInCTIFunctions = opcodeSampleInfo[i].countInCTIFunctions;
</ins><span class="cx">         double percentInCTIFunctions = (static_cast&lt;double&gt;(countInCTIFunctions) * 100) / count;
</span><del>-        fprintf(stdout, &quot;%s:%s%-6lld %.3f%%\t%.3f%%\t  |   %-6lld %.3f%%\n&quot;, bytecodeName, bytecodePadding, count, percentOfVM, percentOfTotal, countInCTIFunctions, percentInCTIFunctions);
</del><ins>+        fprintf(stdout, &quot;%s:%s%-6lld %.3f%%\t%.3f%%\t  |   %-6lld %.3f%%\n&quot;, opcodeName, opcodePadding, count, percentOfVM, percentOfTotal, countInCTIFunctions, percentInCTIFunctions);
</ins><span class="cx">     }
</span><span class="cx">     
</span><span class="cx">     printf(&quot;\n[*] Samples inside host code are not charged to any Bytecode.\n\n&quot;);
</span><del>-    printf(&quot;\tSamples inside VM:\t\t%lld / %lld (%.3f%%)\n&quot;, m_bytecodeSampleCount, m_sampleCount, (static_cast&lt;double&gt;(m_bytecodeSampleCount) * 100) / m_sampleCount);
-    printf(&quot;\tSamples inside host code:\t%lld / %lld (%.3f%%)\n\n&quot;, m_sampleCount - m_bytecodeSampleCount, m_sampleCount, (static_cast&lt;double&gt;(m_sampleCount - m_bytecodeSampleCount) * 100) / m_sampleCount);
-    printf(&quot;\tsample count:\tsamples inside this bytecode\n&quot;);
-    printf(&quot;\t%% of VM:\tsample count / all bytecode samples\n&quot;);
</del><ins>+    printf(&quot;\tSamples inside VM:\t\t%lld / %lld (%.3f%%)\n&quot;, m_opcodeSampleCount, m_sampleCount, (static_cast&lt;double&gt;(m_opcodeSampleCount) * 100) / m_sampleCount);
+    printf(&quot;\tSamples inside host code:\t%lld / %lld (%.3f%%)\n\n&quot;, m_sampleCount - m_opcodeSampleCount, m_sampleCount, (static_cast&lt;double&gt;(m_sampleCount - m_opcodeSampleCount) * 100) / m_sampleCount);
+    printf(&quot;\tsample count:\tsamples inside this opcode\n&quot;);
+    printf(&quot;\t%% of VM:\tsample count / all opcode samples\n&quot;);
</ins><span class="cx">     printf(&quot;\t%% of total:\tsample count / all samples\n&quot;);
</span><span class="cx">     printf(&quot;\t--------------\n&quot;);
</span><del>-    printf(&quot;\tcti count:\tsamples inside a CTI function called by this bytecode\n&quot;);
</del><ins>+    printf(&quot;\tcti count:\tsamples inside a CTI function called by this opcode\n&quot;);
</ins><span class="cx">     printf(&quot;\tcti %% of self:\tcti count / sample count\n&quot;);
</span><span class="cx">     
</span><span class="cx">     // (3) Build and sort 'codeBlockSamples' array.
</span><span class="lines">@@ -254,7 +254,7 @@
</span><span class="cx">                 HashMap&lt;unsigned,unsigned&gt; lineCounts;
</span><span class="cx">                 codeBlock-&gt;dump(exec);
</span><span class="cx"> 
</span><del>-                printf(&quot;    Bytecode and line number samples [*]\n\n&quot;);
</del><ins>+                printf(&quot;    Opcode and line number samples [*]\n\n&quot;);
</ins><span class="cx">                 for (unsigned op = 0; op &lt; record-&gt;m_size; ++op) {
</span><span class="cx">                     int count = record-&gt;m_samples[op];
</span><span class="cx">                     if (count) {
</span><span class="lines">@@ -280,8 +280,8 @@
</span><span class="cx">                 }
</span><span class="cx">                 printf(&quot;\n&quot;);
</span><span class="cx">                 printf(&quot;    [*] Samples inside host code are charged to the calling Bytecode.\n&quot;);
</span><del>-                printf(&quot;        Samples on a call / return boundary are not charged to a specific bytecode or line.\n\n&quot;);
-                printf(&quot;            Samples on a call / return boundary: %d / %d (%.3f%%)\n\n&quot;, record-&gt;m_sampleCount - record-&gt;m_bytecodeSampleCount, record-&gt;m_sampleCount, (static_cast&lt;double&gt;(record-&gt;m_sampleCount - record-&gt;m_bytecodeSampleCount) * 100) / record-&gt;m_sampleCount);
</del><ins>+                printf(&quot;        Samples on a call / return boundary are not charged to a specific opcode or line.\n\n&quot;);
+                printf(&quot;            Samples on a call / return boundary: %d / %d (%.3f%%)\n\n&quot;, record-&gt;m_sampleCount - record-&gt;m_opcodeSampleCount, record-&gt;m_sampleCount, (static_cast&lt;double&gt;(record-&gt;m_sampleCount - record-&gt;m_opcodeSampleCount) * 100) / record-&gt;m_sampleCount);
</ins><span class="cx">             }
</span><span class="cx">         }
</span><span class="cx">     }
</span></span></pre></div>
<a id="trunkJavaScriptCoreVMSamplingToolh"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/VM/SamplingTool.h (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/VM/SamplingTool.h        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/VM/SamplingTool.h        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -49,7 +49,7 @@
</span><span class="cx">             : m_scope(scope)
</span><span class="cx">             , m_codeBlock(0)
</span><span class="cx">             , m_sampleCount(0)
</span><del>-            , m_bytecodeSampleCount(0)
</del><ins>+            , m_opcodeSampleCount(0)
</ins><span class="cx">             , m_samples(0)
</span><span class="cx">             , m_size(0)
</span><span class="cx">         {
</span><span class="lines">@@ -66,7 +66,7 @@
</span><span class="cx">         RefPtr&lt;ScopeNode&gt; m_scope;
</span><span class="cx">         CodeBlock* m_codeBlock;
</span><span class="cx">         int m_sampleCount;
</span><del>-        int m_bytecodeSampleCount;
</del><ins>+        int m_opcodeSampleCount;
</ins><span class="cx">         int* m_samples;
</span><span class="cx">         unsigned m_size;
</span><span class="cx">     };
</span><span class="lines">@@ -78,7 +78,7 @@
</span><span class="cx">         friend class CallRecord;
</span><span class="cx">         friend class HostCallRecord;
</span><span class="cx">         
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">         class CallRecord : Noncopyable {
</span><span class="cx">         public:
</span><span class="cx">             CallRecord(SamplingTool* samplingTool)
</span><span class="lines">@@ -131,11 +131,11 @@
</span><span class="cx">             , m_codeBlock(0)
</span><span class="cx">             , m_sample(0)
</span><span class="cx">             , m_sampleCount(0)
</span><del>-            , m_bytecodeSampleCount(0)
</del><ins>+            , m_opcodeSampleCount(0)
</ins><span class="cx">             , m_scopeSampleMap(new ScopeSampleRecordMap())
</span><span class="cx">         {
</span><del>-            memset(m_bytecodeSamples, 0, sizeof(m_bytecodeSamples));
-            memset(m_bytecodeSamplesInCTIFunctions, 0, sizeof(m_bytecodeSamplesInCTIFunctions));
</del><ins>+            memset(m_opcodeSamples, 0, sizeof(m_opcodeSamples));
+            memset(m_opcodeSamplesInCTIFunctions, 0, sizeof(m_opcodeSamplesInCTIFunctions));
</ins><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         ~SamplingTool()
</span><span class="lines">@@ -201,9 +201,9 @@
</span><span class="cx"> 
</span><span class="cx">         // Gathered sample data.
</span><span class="cx">         long long m_sampleCount;
</span><del>-        long long m_bytecodeSampleCount;
-        unsigned m_bytecodeSamples[numBytecodeIDs];
-        unsigned m_bytecodeSamplesInCTIFunctions[numBytecodeIDs];
</del><ins>+        long long m_opcodeSampleCount;
+        unsigned m_opcodeSamples[numOpcodeIDs];
+        unsigned m_opcodeSamplesInCTIFunctions[numOpcodeIDs];
</ins><span class="cx">         
</span><span class="cx">         Mutex m_scopeSampleMapMutex;
</span><span class="cx">         OwnPtr&lt;ScopeSampleRecordMap&gt; m_scopeSampleMap;
</span></span></pre></div>
<a id="trunkJavaScriptCorebytecompilerCodeGeneratorcpp"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/bytecompiler/CodeGenerator.cpp (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/bytecompiler/CodeGenerator.cpp        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/bytecompiler/CodeGenerator.cpp        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -227,13 +227,13 @@
</span><span class="cx">     , m_codeType(GlobalCode)
</span><span class="cx">     , m_nextGlobalIndex(-1)
</span><span class="cx">     , m_globalData(&amp;scopeChain.globalObject()-&gt;globalExec()-&gt;globalData())
</span><del>-    , m_lastBytecodeID(op_end)
</del><ins>+    , m_lastOpcodeID(op_end)
</ins><span class="cx">     , m_emitNodeDepth(0)
</span><span class="cx"> {
</span><span class="cx">     if (m_shouldEmitDebugHooks)
</span><span class="cx">         m_codeBlock-&gt;needsFullScopeChain = true;
</span><span class="cx"> 
</span><del>-    emitBytecode(op_enter);
</del><ins>+    emitOpcode(op_enter);
</ins><span class="cx">     codeBlock-&gt;globalData = m_globalData;
</span><span class="cx"> 
</span><span class="cx">     // FIXME: Move code that modifies the global object to BytecodeInterpreter::execute.
</span><span class="lines">@@ -304,7 +304,7 @@
</span><span class="cx">     , m_dynamicScopeDepth(0)
</span><span class="cx">     , m_codeType(FunctionCode)
</span><span class="cx">     , m_globalData(&amp;scopeChain.globalObject()-&gt;globalExec()-&gt;globalData())
</span><del>-    , m_lastBytecodeID(op_end)
</del><ins>+    , m_lastOpcodeID(op_end)
</ins><span class="cx">     , m_emitNodeDepth(0)
</span><span class="cx"> {
</span><span class="cx">     if (m_shouldEmitDebugHooks)
</span><span class="lines">@@ -322,13 +322,13 @@
</span><span class="cx">     if (m_codeBlock-&gt;needsFullScopeChain) {
</span><span class="cx">         ++m_codeBlock-&gt;numVars;
</span><span class="cx">         m_activationRegisterIndex = newRegister()-&gt;index();
</span><del>-        emitBytecode(op_enter_with_activation);
</del><ins>+        emitOpcode(op_enter_with_activation);
</ins><span class="cx">         instructions().append(m_activationRegisterIndex);
</span><span class="cx">     } else
</span><del>-        emitBytecode(op_enter);
</del><ins>+        emitOpcode(op_enter);
</ins><span class="cx"> 
</span><span class="cx">     if (usesArguments)
</span><del>-        emitBytecode(op_create_arguments);
</del><ins>+        emitOpcode(op_create_arguments);
</ins><span class="cx"> 
</span><span class="cx">     const DeclarationStacks::FunctionStack&amp; functionStack = functionBody-&gt;functionStack();
</span><span class="cx">     for (size_t i = 0; i &lt; functionStack.size(); ++i) {
</span><span class="lines">@@ -353,7 +353,7 @@
</span><span class="cx">     ++m_codeBlock-&gt;numParameters;
</span><span class="cx"> 
</span><span class="cx">     if (functionBody-&gt;usesThis()) {
</span><del>-        emitBytecode(op_convert_this);
</del><ins>+        emitOpcode(op_convert_this);
</ins><span class="cx">         instructions().append(m_thisRegister.index());
</span><span class="cx">     }
</span><span class="cx">     
</span><span class="lines">@@ -375,13 +375,13 @@
</span><span class="cx">     , m_dynamicScopeDepth(0)
</span><span class="cx">     , m_codeType(EvalCode)
</span><span class="cx">     , m_globalData(&amp;scopeChain.globalObject()-&gt;globalExec()-&gt;globalData())
</span><del>-    , m_lastBytecodeID(op_end)
</del><ins>+    , m_lastOpcodeID(op_end)
</ins><span class="cx">     , m_emitNodeDepth(0)
</span><span class="cx"> {
</span><span class="cx">     if (m_shouldEmitDebugHooks)
</span><span class="cx">         m_codeBlock-&gt;needsFullScopeChain = true;
</span><span class="cx"> 
</span><del>-    emitBytecode(op_enter);
</del><ins>+    emitOpcode(op_enter);
</ins><span class="cx">     codeBlock-&gt;globalData = m_globalData;
</span><span class="cx">     m_codeBlock-&gt;numParameters = 1; // Allocate space for &quot;this&quot;
</span><span class="cx"> 
</span><span class="lines">@@ -512,14 +512,14 @@
</span><span class="cx">     m_codeBlock-&gt;jumpTargets.append(newLabelIndex);
</span><span class="cx"> 
</span><span class="cx">     // This disables peephole optimizations when an instruction is a jump target
</span><del>-    m_lastBytecodeID = op_end;
</del><ins>+    m_lastOpcodeID = op_end;
</ins><span class="cx">     return l0;
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-void BytecodeGenerator::emitBytecode(BytecodeID bytecodeID)
</del><ins>+void BytecodeGenerator::emitOpcode(OpcodeID opcodeID)
</ins><span class="cx"> {
</span><del>-    instructions().append(globalData()-&gt;interpreter-&gt;getBytecode(bytecodeID));
-    m_lastBytecodeID = bytecodeID;
</del><ins>+    instructions().append(globalData()-&gt;interpreter-&gt;getOpcode(opcodeID));
+    m_lastOpcodeID = opcodeID;
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void BytecodeGenerator::retrieveLastBinaryOp(int&amp; dstIndex, int&amp; src1Index, int&amp; src2Index)
</span><span class="lines">@@ -553,14 +553,14 @@
</span><span class="cx"> 
</span><span class="cx"> PassRefPtr&lt;LabelID&gt; BytecodeGenerator::emitJump(LabelID* target)
</span><span class="cx"> {
</span><del>-    emitBytecode(target-&gt;isForwardLabel() ? op_jmp : op_loop);
</del><ins>+    emitOpcode(target-&gt;isForwardLabel() ? op_jmp : op_loop);
</ins><span class="cx">     instructions().append(target-&gt;offsetFrom(instructions().size()));
</span><span class="cx">     return target;
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> PassRefPtr&lt;LabelID&gt; BytecodeGenerator::emitJumpIfTrue(RegisterID* cond, LabelID* target)
</span><span class="cx"> {
</span><del>-    if (m_lastBytecodeID == op_less &amp;&amp; !target-&gt;isForwardLabel()) {
</del><ins>+    if (m_lastOpcodeID == op_less &amp;&amp; !target-&gt;isForwardLabel()) {
</ins><span class="cx">         int dstIndex;
</span><span class="cx">         int src1Index;
</span><span class="cx">         int src2Index;
</span><span class="lines">@@ -569,13 +569,13 @@
</span><span class="cx"> 
</span><span class="cx">         if (cond-&gt;index() == dstIndex &amp;&amp; cond-&gt;isTemporary() &amp;&amp; !cond-&gt;refCount()) {
</span><span class="cx">             rewindBinaryOp();
</span><del>-            emitBytecode(op_loop_if_less);
</del><ins>+            emitOpcode(op_loop_if_less);
</ins><span class="cx">             instructions().append(src1Index);
</span><span class="cx">             instructions().append(src2Index);
</span><span class="cx">             instructions().append(target-&gt;offsetFrom(instructions().size()));
</span><span class="cx">             return target;
</span><span class="cx">         }
</span><del>-    } else if (m_lastBytecodeID == op_lesseq &amp;&amp; !target-&gt;isForwardLabel()) {
</del><ins>+    } else if (m_lastOpcodeID == op_lesseq &amp;&amp; !target-&gt;isForwardLabel()) {
</ins><span class="cx">         int dstIndex;
</span><span class="cx">         int src1Index;
</span><span class="cx">         int src2Index;
</span><span class="lines">@@ -584,13 +584,13 @@
</span><span class="cx"> 
</span><span class="cx">         if (cond-&gt;index() == dstIndex &amp;&amp; cond-&gt;isTemporary() &amp;&amp; !cond-&gt;refCount()) {
</span><span class="cx">             rewindBinaryOp();
</span><del>-            emitBytecode(op_loop_if_lesseq);
</del><ins>+            emitOpcode(op_loop_if_lesseq);
</ins><span class="cx">             instructions().append(src1Index);
</span><span class="cx">             instructions().append(src2Index);
</span><span class="cx">             instructions().append(target-&gt;offsetFrom(instructions().size()));
</span><span class="cx">             return target;
</span><span class="cx">         }
</span><del>-    } else if (m_lastBytecodeID == op_eq_null &amp;&amp; target-&gt;isForwardLabel()) {
</del><ins>+    } else if (m_lastOpcodeID == op_eq_null &amp;&amp; target-&gt;isForwardLabel()) {
</ins><span class="cx">         int dstIndex;
</span><span class="cx">         int srcIndex;
</span><span class="cx"> 
</span><span class="lines">@@ -598,12 +598,12 @@
</span><span class="cx"> 
</span><span class="cx">         if (cond-&gt;index() == dstIndex &amp;&amp; cond-&gt;isTemporary() &amp;&amp; !cond-&gt;refCount()) {
</span><span class="cx">             rewindUnaryOp();
</span><del>-            emitBytecode(op_jeq_null);
</del><ins>+            emitOpcode(op_jeq_null);
</ins><span class="cx">             instructions().append(srcIndex);
</span><span class="cx">             instructions().append(target-&gt;offsetFrom(instructions().size()));
</span><span class="cx">             return target;
</span><span class="cx">         }
</span><del>-    } else if (m_lastBytecodeID == op_neq_null &amp;&amp; target-&gt;isForwardLabel()) {
</del><ins>+    } else if (m_lastOpcodeID == op_neq_null &amp;&amp; target-&gt;isForwardLabel()) {
</ins><span class="cx">         int dstIndex;
</span><span class="cx">         int srcIndex;
</span><span class="cx"> 
</span><span class="lines">@@ -611,14 +611,14 @@
</span><span class="cx"> 
</span><span class="cx">         if (cond-&gt;index() == dstIndex &amp;&amp; cond-&gt;isTemporary() &amp;&amp; !cond-&gt;refCount()) {
</span><span class="cx">             rewindUnaryOp();
</span><del>-            emitBytecode(op_jneq_null);
</del><ins>+            emitOpcode(op_jneq_null);
</ins><span class="cx">             instructions().append(srcIndex);
</span><span class="cx">             instructions().append(target-&gt;offsetFrom(instructions().size()));
</span><span class="cx">             return target;
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    emitBytecode(target-&gt;isForwardLabel() ? op_jtrue : op_loop_if_true);
</del><ins>+    emitOpcode(target-&gt;isForwardLabel() ? op_jtrue : op_loop_if_true);
</ins><span class="cx">     instructions().append(cond-&gt;index());
</span><span class="cx">     instructions().append(target-&gt;offsetFrom(instructions().size()));
</span><span class="cx">     return target;
</span><span class="lines">@@ -628,7 +628,7 @@
</span><span class="cx"> {
</span><span class="cx">     ASSERT(target-&gt;isForwardLabel());
</span><span class="cx"> 
</span><del>-    if (m_lastBytecodeID == op_less) {
</del><ins>+    if (m_lastOpcodeID == op_less) {
</ins><span class="cx">         int dstIndex;
</span><span class="cx">         int src1Index;
</span><span class="cx">         int src2Index;
</span><span class="lines">@@ -637,13 +637,13 @@
</span><span class="cx"> 
</span><span class="cx">         if (cond-&gt;index() == dstIndex &amp;&amp; cond-&gt;isTemporary() &amp;&amp; !cond-&gt;refCount()) {
</span><span class="cx">             rewindBinaryOp();
</span><del>-            emitBytecode(op_jnless);
</del><ins>+            emitOpcode(op_jnless);
</ins><span class="cx">             instructions().append(src1Index);
</span><span class="cx">             instructions().append(src2Index);
</span><span class="cx">             instructions().append(target-&gt;offsetFrom(instructions().size()));
</span><span class="cx">             return target;
</span><span class="cx">         }
</span><del>-    } else if (m_lastBytecodeID == op_not) {
</del><ins>+    } else if (m_lastOpcodeID == op_not) {
</ins><span class="cx">         int dstIndex;
</span><span class="cx">         int srcIndex;
</span><span class="cx"> 
</span><span class="lines">@@ -651,12 +651,12 @@
</span><span class="cx"> 
</span><span class="cx">         if (cond-&gt;index() == dstIndex &amp;&amp; cond-&gt;isTemporary() &amp;&amp; !cond-&gt;refCount()) {
</span><span class="cx">             rewindUnaryOp();
</span><del>-            emitBytecode(op_jtrue);
</del><ins>+            emitOpcode(op_jtrue);
</ins><span class="cx">             instructions().append(srcIndex);
</span><span class="cx">             instructions().append(target-&gt;offsetFrom(instructions().size()));
</span><span class="cx">             return target;
</span><span class="cx">         }
</span><del>-    } else if (m_lastBytecodeID == op_eq_null) {
</del><ins>+    } else if (m_lastOpcodeID == op_eq_null) {
</ins><span class="cx">         int dstIndex;
</span><span class="cx">         int srcIndex;
</span><span class="cx"> 
</span><span class="lines">@@ -664,12 +664,12 @@
</span><span class="cx"> 
</span><span class="cx">         if (cond-&gt;index() == dstIndex &amp;&amp; cond-&gt;isTemporary() &amp;&amp; !cond-&gt;refCount()) {
</span><span class="cx">             rewindUnaryOp();
</span><del>-            emitBytecode(op_jneq_null);
</del><ins>+            emitOpcode(op_jneq_null);
</ins><span class="cx">             instructions().append(srcIndex);
</span><span class="cx">             instructions().append(target-&gt;offsetFrom(instructions().size()));
</span><span class="cx">             return target;
</span><span class="cx">         }
</span><del>-    } else if (m_lastBytecodeID == op_neq_null) {
</del><ins>+    } else if (m_lastOpcodeID == op_neq_null) {
</ins><span class="cx">         int dstIndex;
</span><span class="cx">         int srcIndex;
</span><span class="cx"> 
</span><span class="lines">@@ -677,14 +677,14 @@
</span><span class="cx"> 
</span><span class="cx">         if (cond-&gt;index() == dstIndex &amp;&amp; cond-&gt;isTemporary() &amp;&amp; !cond-&gt;refCount()) {
</span><span class="cx">             rewindUnaryOp();
</span><del>-            emitBytecode(op_jeq_null);
</del><ins>+            emitOpcode(op_jeq_null);
</ins><span class="cx">             instructions().append(srcIndex);
</span><span class="cx">             instructions().append(target-&gt;offsetFrom(instructions().size()));
</span><span class="cx">             return target;
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    emitBytecode(op_jfalse);
</del><ins>+    emitOpcode(op_jfalse);
</ins><span class="cx">     instructions().append(cond-&gt;index());
</span><span class="cx">     instructions().append(target-&gt;offsetFrom(instructions().size()));
</span><span class="cx">     return target;
</span><span class="lines">@@ -747,39 +747,39 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitMove(RegisterID* dst, RegisterID* src)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_mov);
</del><ins>+    emitOpcode(op_mov);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(src-&gt;index());
</span><span class="cx">     return dst;
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-RegisterID* BytecodeGenerator::emitUnaryOp(BytecodeID bytecode, RegisterID* dst, RegisterID* src, ResultType type)
</del><ins>+RegisterID* BytecodeGenerator::emitUnaryOp(OpcodeID opcodeID, RegisterID* dst, RegisterID* src, ResultType type)
</ins><span class="cx"> {
</span><del>-    emitBytecode(bytecode);
</del><ins>+    emitOpcode(opcodeID);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(src-&gt;index());
</span><del>-    if (bytecode == op_negate)
</del><ins>+    if (opcodeID == op_negate)
</ins><span class="cx">         instructions().append(type.toInt());
</span><span class="cx">     return dst;
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitPreInc(RegisterID* srcDst)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_pre_inc);
</del><ins>+    emitOpcode(op_pre_inc);
</ins><span class="cx">     instructions().append(srcDst-&gt;index());
</span><span class="cx">     return srcDst;
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitPreDec(RegisterID* srcDst)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_pre_dec);
</del><ins>+    emitOpcode(op_pre_dec);
</ins><span class="cx">     instructions().append(srcDst-&gt;index());
</span><span class="cx">     return srcDst;
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitPostInc(RegisterID* dst, RegisterID* srcDst)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_post_inc);
</del><ins>+    emitOpcode(op_post_inc);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(srcDst-&gt;index());
</span><span class="cx">     return dst;
</span><span class="lines">@@ -787,30 +787,30 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitPostDec(RegisterID* dst, RegisterID* srcDst)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_post_dec);
</del><ins>+    emitOpcode(op_post_dec);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(srcDst-&gt;index());
</span><span class="cx">     return dst;
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-RegisterID* BytecodeGenerator::emitBinaryOp(BytecodeID bytecode, RegisterID* dst, RegisterID* src1, RegisterID* src2, OperandTypes types)
</del><ins>+RegisterID* BytecodeGenerator::emitBinaryOp(OpcodeID opcodeID, RegisterID* dst, RegisterID* src1, RegisterID* src2, OperandTypes types)
</ins><span class="cx"> {
</span><del>-    emitBytecode(bytecode);
</del><ins>+    emitOpcode(opcodeID);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(src1-&gt;index());
</span><span class="cx">     instructions().append(src2-&gt;index());
</span><span class="cx"> 
</span><del>-    if (bytecode == op_bitor || bytecode == op_bitand || bytecode == op_bitxor ||
-        bytecode == op_add || bytecode == op_mul || bytecode == op_sub) {
</del><ins>+    if (opcodeID == op_bitor || opcodeID == op_bitand || opcodeID == op_bitxor ||
+        opcodeID == op_add || opcodeID == op_mul || opcodeID == op_sub) {
</ins><span class="cx">         instructions().append(types.toInt());
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     return dst;
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-RegisterID* BytecodeGenerator::emitEqualityOp(BytecodeID bytecode, RegisterID* dst, RegisterID* src1, RegisterID* src2)
</del><ins>+RegisterID* BytecodeGenerator::emitEqualityOp(OpcodeID opcodeID, RegisterID* dst, RegisterID* src1, RegisterID* src2)
</ins><span class="cx"> {
</span><del>-    if (m_lastBytecodeID == op_typeof) {
</del><ins>+    if (m_lastOpcodeID == op_typeof) {
</ins><span class="cx">         int dstIndex;
</span><span class="cx">         int srcIndex;
</span><span class="cx"> 
</span><span class="lines">@@ -823,42 +823,42 @@
</span><span class="cx">             const UString&amp; value = asString(m_codeBlock-&gt;constantRegisters[src2-&gt;index() - m_codeBlock-&gt;numVars].jsValue(m_scopeChain-&gt;globalObject()-&gt;globalExec()))-&gt;value();
</span><span class="cx">             if (value == &quot;undefined&quot;) {
</span><span class="cx">                 rewindUnaryOp();
</span><del>-                emitBytecode(op_is_undefined);
</del><ins>+                emitOpcode(op_is_undefined);
</ins><span class="cx">                 instructions().append(dst-&gt;index());
</span><span class="cx">                 instructions().append(srcIndex);
</span><span class="cx">                 return dst;
</span><span class="cx">             }
</span><span class="cx">             if (value == &quot;boolean&quot;) {
</span><span class="cx">                 rewindUnaryOp();
</span><del>-                emitBytecode(op_is_boolean);
</del><ins>+                emitOpcode(op_is_boolean);
</ins><span class="cx">                 instructions().append(dst-&gt;index());
</span><span class="cx">                 instructions().append(srcIndex);
</span><span class="cx">                 return dst;
</span><span class="cx">             }
</span><span class="cx">             if (value == &quot;number&quot;) {
</span><span class="cx">                 rewindUnaryOp();
</span><del>-                emitBytecode(op_is_number);
</del><ins>+                emitOpcode(op_is_number);
</ins><span class="cx">                 instructions().append(dst-&gt;index());
</span><span class="cx">                 instructions().append(srcIndex);
</span><span class="cx">                 return dst;
</span><span class="cx">             }
</span><span class="cx">             if (value == &quot;string&quot;) {
</span><span class="cx">                 rewindUnaryOp();
</span><del>-                emitBytecode(op_is_string);
</del><ins>+                emitOpcode(op_is_string);
</ins><span class="cx">                 instructions().append(dst-&gt;index());
</span><span class="cx">                 instructions().append(srcIndex);
</span><span class="cx">                 return dst;
</span><span class="cx">             }
</span><span class="cx">             if (value == &quot;object&quot;) {
</span><span class="cx">                 rewindUnaryOp();
</span><del>-                emitBytecode(op_is_object);
</del><ins>+                emitOpcode(op_is_object);
</ins><span class="cx">                 instructions().append(dst-&gt;index());
</span><span class="cx">                 instructions().append(srcIndex);
</span><span class="cx">                 return dst;
</span><span class="cx">             }
</span><span class="cx">             if (value == &quot;function&quot;) {
</span><span class="cx">                 rewindUnaryOp();
</span><del>-                emitBytecode(op_is_function);
</del><ins>+                emitOpcode(op_is_function);
</ins><span class="cx">                 instructions().append(dst-&gt;index());
</span><span class="cx">                 instructions().append(srcIndex);
</span><span class="cx">                 return dst;
</span><span class="lines">@@ -866,7 +866,7 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    emitBytecode(bytecode);
</del><ins>+    emitOpcode(opcodeID);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(src1-&gt;index());
</span><span class="cx">     instructions().append(src2-&gt;index());
</span><span class="lines">@@ -914,7 +914,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitUnexpectedLoad(RegisterID* dst, bool b)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_unexpected_load);
</del><ins>+    emitOpcode(op_unexpected_load);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(addUnexpectedConstant(jsBoolean(b)));
</span><span class="cx">     return dst;
</span><span class="lines">@@ -922,7 +922,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitUnexpectedLoad(RegisterID* dst, double d)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_unexpected_load);
</del><ins>+    emitOpcode(op_unexpected_load);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(addUnexpectedConstant(jsNumber(globalData(), d)));
</span><span class="cx">     return dst;
</span><span class="lines">@@ -984,7 +984,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitInstanceOf(RegisterID* dst, RegisterID* value, RegisterID* base, RegisterID* basePrototype)
</span><span class="cx"> { 
</span><del>-    emitBytecode(op_instanceof);
</del><ins>+    emitOpcode(op_instanceof);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(value-&gt;index());
</span><span class="cx">     instructions().append(base-&gt;index());
</span><span class="lines">@@ -999,7 +999,7 @@
</span><span class="cx">     JSObject* globalObject = 0;
</span><span class="cx">     if (!findScopedProperty(property, index, depth, false, globalObject) &amp;&amp; !globalObject) {
</span><span class="cx">         // We can't optimise at all :-(
</span><del>-        emitBytecode(op_resolve);
</del><ins>+        emitOpcode(op_resolve);
</ins><span class="cx">         instructions().append(dst-&gt;index());
</span><span class="cx">         instructions().append(addConstant(property));
</span><span class="cx">         return dst;
</span><span class="lines">@@ -1012,7 +1012,7 @@
</span><span class="cx"> 
</span><span class="cx">     if (globalObject) {
</span><span class="cx">         m_codeBlock-&gt;globalResolveInstructions.append(instructions().size());
</span><del>-        emitBytecode(op_resolve_global);
</del><ins>+        emitOpcode(op_resolve_global);
</ins><span class="cx">         instructions().append(dst-&gt;index());
</span><span class="cx">         instructions().append(globalObject);
</span><span class="cx">         instructions().append(addConstant(property));
</span><span class="lines">@@ -1023,7 +1023,7 @@
</span><span class="cx"> 
</span><span class="cx">     // In this case we are at least able to drop a few scope chains from the
</span><span class="cx">     // lookup chain, although we still need to hash from then on.
</span><del>-    emitBytecode(op_resolve_skip);
</del><ins>+    emitOpcode(op_resolve_skip);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(addConstant(property));
</span><span class="cx">     instructions().append(depth);
</span><span class="lines">@@ -1033,14 +1033,14 @@
</span><span class="cx"> RegisterID* BytecodeGenerator::emitGetScopedVar(RegisterID* dst, size_t depth, int index, JSValue* globalObject)
</span><span class="cx"> {
</span><span class="cx">     if (globalObject) {
</span><del>-        emitBytecode(op_get_global_var);
</del><ins>+        emitOpcode(op_get_global_var);
</ins><span class="cx">         instructions().append(dst-&gt;index());
</span><span class="cx">         instructions().append(asCell(globalObject));
</span><span class="cx">         instructions().append(index);
</span><span class="cx">         return dst;
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    emitBytecode(op_get_scoped_var);
</del><ins>+    emitOpcode(op_get_scoped_var);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(index);
</span><span class="cx">     instructions().append(depth);
</span><span class="lines">@@ -1050,13 +1050,13 @@
</span><span class="cx"> RegisterID* BytecodeGenerator::emitPutScopedVar(size_t depth, int index, RegisterID* value, JSValue* globalObject)
</span><span class="cx"> {
</span><span class="cx">     if (globalObject) {
</span><del>-        emitBytecode(op_put_global_var);
</del><ins>+        emitOpcode(op_put_global_var);
</ins><span class="cx">         instructions().append(asCell(globalObject));
</span><span class="cx">         instructions().append(index);
</span><span class="cx">         instructions().append(value-&gt;index());
</span><span class="cx">         return value;
</span><span class="cx">     }
</span><del>-    emitBytecode(op_put_scoped_var);
</del><ins>+    emitOpcode(op_put_scoped_var);
</ins><span class="cx">     instructions().append(index);
</span><span class="cx">     instructions().append(depth);
</span><span class="cx">     instructions().append(value-&gt;index());
</span><span class="lines">@@ -1065,7 +1065,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitResolveBase(RegisterID* dst, const Identifier&amp; property)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_resolve_base);
</del><ins>+    emitOpcode(op_resolve_base);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(addConstant(property));
</span><span class="cx">     return dst;
</span><span class="lines">@@ -1073,7 +1073,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitResolveWithBase(RegisterID* baseDst, RegisterID* propDst, const Identifier&amp; property)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_resolve_with_base);
</del><ins>+    emitOpcode(op_resolve_with_base);
</ins><span class="cx">     instructions().append(baseDst-&gt;index());
</span><span class="cx">     instructions().append(propDst-&gt;index());
</span><span class="cx">     instructions().append(addConstant(property));
</span><span class="lines">@@ -1082,7 +1082,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitResolveFunction(RegisterID* baseDst, RegisterID* funcDst, const Identifier&amp; property)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_resolve_func);
</del><ins>+    emitOpcode(op_resolve_func);
</ins><span class="cx">     instructions().append(baseDst-&gt;index());
</span><span class="cx">     instructions().append(funcDst-&gt;index());
</span><span class="cx">     instructions().append(addConstant(property));
</span><span class="lines">@@ -1093,7 +1093,7 @@
</span><span class="cx"> {
</span><span class="cx">     m_codeBlock-&gt;propertyAccessInstructions.append(instructions().size());
</span><span class="cx"> 
</span><del>-    emitBytecode(op_get_by_id);
</del><ins>+    emitOpcode(op_get_by_id);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(base-&gt;index());
</span><span class="cx">     instructions().append(addConstant(property));
</span><span class="lines">@@ -1108,7 +1108,7 @@
</span><span class="cx"> {
</span><span class="cx">     m_codeBlock-&gt;propertyAccessInstructions.append(instructions().size());
</span><span class="cx"> 
</span><del>-    emitBytecode(op_put_by_id);
</del><ins>+    emitOpcode(op_put_by_id);
</ins><span class="cx">     instructions().append(base-&gt;index());
</span><span class="cx">     instructions().append(addConstant(property));
</span><span class="cx">     instructions().append(value-&gt;index());
</span><span class="lines">@@ -1121,7 +1121,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitPutGetter(RegisterID* base, const Identifier&amp; property, RegisterID* value)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_put_getter);
</del><ins>+    emitOpcode(op_put_getter);
</ins><span class="cx">     instructions().append(base-&gt;index());
</span><span class="cx">     instructions().append(addConstant(property));
</span><span class="cx">     instructions().append(value-&gt;index());
</span><span class="lines">@@ -1130,7 +1130,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitPutSetter(RegisterID* base, const Identifier&amp; property, RegisterID* value)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_put_setter);
</del><ins>+    emitOpcode(op_put_setter);
</ins><span class="cx">     instructions().append(base-&gt;index());
</span><span class="cx">     instructions().append(addConstant(property));
</span><span class="cx">     instructions().append(value-&gt;index());
</span><span class="lines">@@ -1139,7 +1139,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitDeleteById(RegisterID* dst, RegisterID* base, const Identifier&amp; property)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_del_by_id);
</del><ins>+    emitOpcode(op_del_by_id);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(base-&gt;index());
</span><span class="cx">     instructions().append(addConstant(property));
</span><span class="lines">@@ -1148,7 +1148,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitGetByVal(RegisterID* dst, RegisterID* base, RegisterID* property)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_get_by_val);
</del><ins>+    emitOpcode(op_get_by_val);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(base-&gt;index());
</span><span class="cx">     instructions().append(property-&gt;index());
</span><span class="lines">@@ -1157,7 +1157,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitPutByVal(RegisterID* base, RegisterID* property, RegisterID* value)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_put_by_val);
</del><ins>+    emitOpcode(op_put_by_val);
</ins><span class="cx">     instructions().append(base-&gt;index());
</span><span class="cx">     instructions().append(property-&gt;index());
</span><span class="cx">     instructions().append(value-&gt;index());
</span><span class="lines">@@ -1166,7 +1166,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitDeleteByVal(RegisterID* dst, RegisterID* base, RegisterID* property)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_del_by_val);
</del><ins>+    emitOpcode(op_del_by_val);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(base-&gt;index());
</span><span class="cx">     instructions().append(property-&gt;index());
</span><span class="lines">@@ -1175,7 +1175,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitPutByIndex(RegisterID* base, unsigned index, RegisterID* value)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_put_by_index);
</del><ins>+    emitOpcode(op_put_by_index);
</ins><span class="cx">     instructions().append(base-&gt;index());
</span><span class="cx">     instructions().append(index);
</span><span class="cx">     instructions().append(value-&gt;index());
</span><span class="lines">@@ -1184,7 +1184,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitNewObject(RegisterID* dst)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_new_object);
</del><ins>+    emitOpcode(op_new_object);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     return dst;
</span><span class="cx"> }
</span><span class="lines">@@ -1198,7 +1198,7 @@
</span><span class="cx">         argv.append(newTemporary());
</span><span class="cx">         emitNode(argv.last().get(), n-&gt;value());
</span><span class="cx">     }
</span><del>-    emitBytecode(op_new_array);
</del><ins>+    emitOpcode(op_new_array);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(argv.size() ? argv[0]-&gt;index() : 0); // argv
</span><span class="cx">     instructions().append(argv.size()); // argc
</span><span class="lines">@@ -1207,7 +1207,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitNewFunction(RegisterID* dst, FuncDeclNode* n)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_new_func);
</del><ins>+    emitOpcode(op_new_func);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(addConstant(n));
</span><span class="cx">     return dst;
</span><span class="lines">@@ -1215,7 +1215,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitNewRegExp(RegisterID* dst, RegExp* regExp)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_new_regexp);
</del><ins>+    emitOpcode(op_new_regexp);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(addRegExp(regExp));
</span><span class="cx">     return dst;
</span><span class="lines">@@ -1224,7 +1224,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitNewFunctionExpression(RegisterID* r0, FuncExprNode* n)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_new_func_exp);
</del><ins>+    emitOpcode(op_new_func_exp);
</ins><span class="cx">     instructions().append(r0-&gt;index());
</span><span class="cx">     instructions().append(addConstant(n));
</span><span class="cx">     return r0;
</span><span class="lines">@@ -1240,9 +1240,9 @@
</span><span class="cx">     return emitCall(op_call_eval, dst, func, thisRegister, argumentsNode, divot, startOffset, endOffset);
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-RegisterID* BytecodeGenerator::emitCall(BytecodeID bytecodeID, RegisterID* dst, RegisterID* func, RegisterID* thisRegister, ArgumentsNode* argumentsNode, unsigned divot, unsigned startOffset, unsigned endOffset)
</del><ins>+RegisterID* BytecodeGenerator::emitCall(OpcodeID opcodeID, RegisterID* dst, RegisterID* func, RegisterID* thisRegister, ArgumentsNode* argumentsNode, unsigned divot, unsigned startOffset, unsigned endOffset)
</ins><span class="cx"> {
</span><del>-    ASSERT(bytecodeID == op_call || bytecodeID == op_call_eval);
</del><ins>+    ASSERT(opcodeID == op_call || opcodeID == op_call_eval);
</ins><span class="cx">     ASSERT(func-&gt;refCount());
</span><span class="cx"> 
</span><span class="cx">     if (m_shouldEmitProfileHooks) {
</span><span class="lines">@@ -1273,7 +1273,7 @@
</span><span class="cx">         callFrame.append(newTemporary());
</span><span class="cx"> 
</span><span class="cx">     if (m_shouldEmitProfileHooks) {
</span><del>-        emitBytecode(op_profile_will_call);
</del><ins>+        emitOpcode(op_profile_will_call);
</ins><span class="cx">         instructions().append(func-&gt;index());
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -1281,14 +1281,14 @@
</span><span class="cx">     m_codeBlock-&gt;callLinkInfos.append(CallLinkInfo());
</span><span class="cx"> 
</span><span class="cx">     // Emit call.
</span><del>-    emitBytecode(bytecodeID);
</del><ins>+    emitOpcode(opcodeID);
</ins><span class="cx">     instructions().append(dst-&gt;index()); // dst
</span><span class="cx">     instructions().append(func-&gt;index()); // func
</span><span class="cx">     instructions().append(argv.size()); // argCount
</span><span class="cx">     instructions().append(argv[0]-&gt;index() + argv.size() + RegisterFile::CallFrameHeaderSize); // registerOffset
</span><span class="cx"> 
</span><span class="cx">     if (m_shouldEmitProfileHooks) {
</span><del>-        emitBytecode(op_profile_did_call);
</del><ins>+        emitOpcode(op_profile_did_call);
</ins><span class="cx">         instructions().append(func-&gt;index());
</span><span class="cx"> 
</span><span class="cx">         if (dst == func) {
</span><span class="lines">@@ -1303,17 +1303,17 @@
</span><span class="cx"> RegisterID* BytecodeGenerator::emitReturn(RegisterID* src)
</span><span class="cx"> {
</span><span class="cx">     if (m_codeBlock-&gt;needsFullScopeChain) {
</span><del>-        emitBytecode(op_tear_off_activation);
</del><ins>+        emitOpcode(op_tear_off_activation);
</ins><span class="cx">         instructions().append(m_activationRegisterIndex);
</span><span class="cx">     } else if (m_codeBlock-&gt;usesArguments &amp;&amp; m_codeBlock-&gt;numParameters &gt; 1)
</span><del>-        emitBytecode(op_tear_off_arguments);
</del><ins>+        emitOpcode(op_tear_off_arguments);
</ins><span class="cx"> 
</span><span class="cx">     return emitUnaryNoDstOp(op_ret, src);
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-RegisterID* BytecodeGenerator::emitUnaryNoDstOp(BytecodeID bytecode, RegisterID* src)
</del><ins>+RegisterID* BytecodeGenerator::emitUnaryNoDstOp(OpcodeID opcodeID, RegisterID* src)
</ins><span class="cx"> {
</span><del>-    emitBytecode(bytecode);
</del><ins>+    emitOpcode(opcodeID);
</ins><span class="cx">     instructions().append(src-&gt;index());
</span><span class="cx">     return src;
</span><span class="cx"> }
</span><span class="lines">@@ -1343,7 +1343,7 @@
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     if (m_shouldEmitProfileHooks) {
</span><del>-        emitBytecode(op_profile_will_call);
</del><ins>+        emitOpcode(op_profile_will_call);
</ins><span class="cx">         instructions().append(func-&gt;index());
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -1359,7 +1359,7 @@
</span><span class="cx">     emitExpressionInfo(divot, startOffset, endOffset);
</span><span class="cx">     m_codeBlock-&gt;callLinkInfos.append(CallLinkInfo());
</span><span class="cx"> 
</span><del>-    emitBytecode(op_construct);
</del><ins>+    emitOpcode(op_construct);
</ins><span class="cx">     instructions().append(dst-&gt;index()); // dst
</span><span class="cx">     instructions().append(func-&gt;index()); // func
</span><span class="cx">     instructions().append(argv.size()); // argCount
</span><span class="lines">@@ -1367,12 +1367,12 @@
</span><span class="cx">     instructions().append(funcProto-&gt;index()); // proto
</span><span class="cx">     instructions().append(argv[0]-&gt;index()); // thisRegister
</span><span class="cx"> 
</span><del>-    emitBytecode(op_construct_verify);
</del><ins>+    emitOpcode(op_construct_verify);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(argv[0]-&gt;index());
</span><span class="cx"> 
</span><span class="cx">     if (m_shouldEmitProfileHooks) {
</span><del>-        emitBytecode(op_profile_did_call);
</del><ins>+        emitOpcode(op_profile_did_call);
</ins><span class="cx">         instructions().append(func-&gt;index());
</span><span class="cx">         
</span><span class="cx">         if (dst == func)
</span><span class="lines">@@ -1397,7 +1397,7 @@
</span><span class="cx">     ASSERT(m_scopeContextStack.size());
</span><span class="cx">     ASSERT(!m_scopeContextStack.last().isFinallyBlock);
</span><span class="cx"> 
</span><del>-    emitBytecode(op_pop_scope);
</del><ins>+    emitOpcode(op_pop_scope);
</ins><span class="cx"> 
</span><span class="cx">     m_scopeContextStack.removeLast();
</span><span class="cx">     m_dynamicScopeDepth--;
</span><span class="lines">@@ -1407,7 +1407,7 @@
</span><span class="cx"> {
</span><span class="cx">     if (!m_shouldEmitDebugHooks)
</span><span class="cx">         return;
</span><del>-    emitBytecode(op_debug);
</del><ins>+    emitOpcode(op_debug);
</ins><span class="cx">     instructions().append(debugHookID);
</span><span class="cx">     instructions().append(firstLine);
</span><span class="cx">     instructions().append(lastLine);
</span><span class="lines">@@ -1516,7 +1516,7 @@
</span><span class="cx">         if (nNormalScopes) {
</span><span class="cx">             // We need to remove a number of dynamic scopes to get to the next
</span><span class="cx">             // finally block
</span><del>-            emitBytecode(op_jmp_scopes);
</del><ins>+            emitOpcode(op_jmp_scopes);
</ins><span class="cx">             instructions().append(nNormalScopes);
</span><span class="cx"> 
</span><span class="cx">             // If topScope == bottomScope then there isn't actually a finally block
</span><span class="lines">@@ -1558,7 +1558,7 @@
</span><span class="cx">     if (m_finallyDepth)
</span><span class="cx">         return emitComplexJumpScopes(target, &amp;m_scopeContextStack.last(), &amp;m_scopeContextStack.last() - scopeDelta);
</span><span class="cx"> 
</span><del>-    emitBytecode(op_jmp_scopes);
</del><ins>+    emitOpcode(op_jmp_scopes);
</ins><span class="cx">     instructions().append(scopeDelta);
</span><span class="cx">     instructions().append(target-&gt;offsetFrom(instructions().size()));
</span><span class="cx">     return target;
</span><span class="lines">@@ -1566,7 +1566,7 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitNextPropertyName(RegisterID* dst, RegisterID* iter, LabelID* target)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_next_pname);
</del><ins>+    emitOpcode(op_next_pname);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(iter-&gt;index());
</span><span class="cx">     instructions().append(target-&gt;offsetFrom(instructions().size()));
</span><span class="lines">@@ -1577,14 +1577,14 @@
</span><span class="cx"> {
</span><span class="cx">     HandlerInfo info = { start-&gt;offsetFrom(0), end-&gt;offsetFrom(0), instructions().size(), m_dynamicScopeDepth, 0 };
</span><span class="cx">     exceptionHandlers().append(info);
</span><del>-    emitBytecode(op_catch);
</del><ins>+    emitOpcode(op_catch);
</ins><span class="cx">     instructions().append(targetRegister-&gt;index());
</span><span class="cx">     return targetRegister;
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BytecodeGenerator::emitNewError(RegisterID* dst, ErrorType type, JSValue* message)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_new_error);
</del><ins>+    emitOpcode(op_new_error);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(static_cast&lt;int&gt;(type));
</span><span class="cx">     instructions().append(addUnexpectedConstant(message));
</span><span class="lines">@@ -1593,7 +1593,7 @@
</span><span class="cx"> 
</span><span class="cx"> PassRefPtr&lt;LabelID&gt; BytecodeGenerator::emitJumpSubroutine(RegisterID* retAddrDst, LabelID* finally)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_jsr);
</del><ins>+    emitOpcode(op_jsr);
</ins><span class="cx">     instructions().append(retAddrDst-&gt;index());
</span><span class="cx">     instructions().append(finally-&gt;offsetFrom(instructions().size()));
</span><span class="cx">     return finally;
</span><span class="lines">@@ -1601,7 +1601,7 @@
</span><span class="cx"> 
</span><span class="cx"> void BytecodeGenerator::emitSubroutineReturn(RegisterID* retAddrSrc)
</span><span class="cx"> {
</span><del>-    emitBytecode(op_sret);
</del><ins>+    emitOpcode(op_sret);
</ins><span class="cx">     instructions().append(retAddrSrc-&gt;index());
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="lines">@@ -1612,7 +1612,7 @@
</span><span class="cx">     m_scopeContextStack.append(context);
</span><span class="cx">     m_dynamicScopeDepth++;
</span><span class="cx">     
</span><del>-    emitBytecode(op_push_new_scope);
</del><ins>+    emitOpcode(op_push_new_scope);
</ins><span class="cx">     instructions().append(dst-&gt;index());
</span><span class="cx">     instructions().append(addConstant(property));
</span><span class="cx">     instructions().append(value-&gt;index());
</span><span class="lines">@@ -1623,13 +1623,13 @@
</span><span class="cx">     SwitchInfo info = { instructions().size(), type };
</span><span class="cx">     switch (type) {
</span><span class="cx">         case SwitchInfo::SwitchImmediate:
</span><del>-            emitBytecode(op_switch_imm);
</del><ins>+            emitOpcode(op_switch_imm);
</ins><span class="cx">             break;
</span><span class="cx">         case SwitchInfo::SwitchCharacter:
</span><del>-            emitBytecode(op_switch_char);
</del><ins>+            emitOpcode(op_switch_char);
</ins><span class="cx">             break;
</span><span class="cx">         case SwitchInfo::SwitchString:
</span><del>-            emitBytecode(op_switch_string);
</del><ins>+            emitOpcode(op_switch_string);
</ins><span class="cx">             break;
</span><span class="cx">         default:
</span><span class="cx">             ASSERT_NOT_REACHED();
</span></span></pre></div>
<a id="trunkJavaScriptCorebytecompilerCodeGeneratorh"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/bytecompiler/CodeGenerator.h (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/bytecompiler/CodeGenerator.h        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/bytecompiler/CodeGenerator.h        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -231,10 +231,10 @@
</span><span class="cx">         RegisterID* emitUnexpectedLoad(RegisterID* dst, bool);
</span><span class="cx">         RegisterID* emitUnexpectedLoad(RegisterID* dst, double);
</span><span class="cx"> 
</span><del>-        RegisterID* emitUnaryOp(BytecodeID, RegisterID* dst, RegisterID* src, ResultType);
-        RegisterID* emitBinaryOp(BytecodeID, RegisterID* dst, RegisterID* src1, RegisterID* src2, OperandTypes);
-        RegisterID* emitEqualityOp(BytecodeID, RegisterID* dst, RegisterID* src1, RegisterID* src2);
-        RegisterID* emitUnaryNoDstOp(BytecodeID, RegisterID* src);
</del><ins>+        RegisterID* emitUnaryOp(OpcodeID, RegisterID* dst, RegisterID* src, ResultType);
+        RegisterID* emitBinaryOp(OpcodeID, RegisterID* dst, RegisterID* src1, RegisterID* src2, OperandTypes);
+        RegisterID* emitEqualityOp(OpcodeID, RegisterID* dst, RegisterID* src1, RegisterID* src2);
+        RegisterID* emitUnaryNoDstOp(OpcodeID, RegisterID* src);
</ins><span class="cx"> 
</span><span class="cx">         RegisterID* emitNewObject(RegisterID* dst);
</span><span class="cx">         RegisterID* emitNewArray(RegisterID* dst, ElementNode*); // stops at first elision
</span><span class="lines">@@ -317,7 +317,7 @@
</span><span class="cx">         CodeType codeType() const { return m_codeType; }
</span><span class="cx"> 
</span><span class="cx">     private:
</span><del>-        void emitBytecode(BytecodeID);
</del><ins>+        void emitOpcode(OpcodeID);
</ins><span class="cx">         void retrieveLastBinaryOp(int&amp; dstIndex, int&amp; src1Index, int&amp; src2Index);
</span><span class="cx">         void retrieveLastUnaryOp(int&amp; dstIndex, int&amp; srcIndex);
</span><span class="cx">         void rewindBinaryOp();
</span><span class="lines">@@ -345,7 +345,7 @@
</span><span class="cx">         typedef HashMap&lt;double, JSValue*&gt; NumberMap;
</span><span class="cx">         typedef HashMap&lt;UString::Rep*, JSString*, IdentifierRepHash&gt; IdentifierStringMap;
</span><span class="cx"> 
</span><del>-        RegisterID* emitCall(BytecodeID, RegisterID* dst, RegisterID* func, RegisterID* thisRegister, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
</del><ins>+        RegisterID* emitCall(OpcodeID, RegisterID* dst, RegisterID* func, RegisterID* thisRegister, ArgumentsNode*, unsigned divot, unsigned startOffset, unsigned endOffset);
</ins><span class="cx">         
</span><span class="cx">         RegisterID* newRegister();
</span><span class="cx"> 
</span><span class="lines">@@ -446,7 +446,7 @@
</span><span class="cx"> 
</span><span class="cx">         JSGlobalData* m_globalData;
</span><span class="cx"> 
</span><del>-        BytecodeID m_lastBytecodeID;
</del><ins>+        OpcodeID m_lastOpcodeID;
</ins><span class="cx"> 
</span><span class="cx"> #ifndef NDEBUG
</span><span class="cx">         static bool s_dumpsGeneratedCode;
</span></span></pre></div>
<a id="trunkJavaScriptCorejsccpp"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/jsc.cpp (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/jsc.cpp        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/jsc.cpp        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -320,7 +320,7 @@
</span><span class="cx">     if (dump)
</span><span class="cx">         BytecodeGenerator::setDumpsGeneratedCode(true);
</span><span class="cx"> 
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     BytecodeInterpreter* interpreter = globalObject-&gt;globalData()-&gt;interpreter;
</span><span class="cx">     interpreter-&gt;setSampler(new SamplingTool(machine));
</span><span class="cx"> #endif
</span><span class="lines">@@ -332,7 +332,7 @@
</span><span class="cx">         if (!fillBufferWithContentsOfFile(fileName, script))
</span><span class="cx">             return false; // fail early so we can catch missing files
</span><span class="cx"> 
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">         interpreter-&gt;sampler()-&gt;start();
</span><span class="cx"> #endif
</span><span class="cx">         Completion completion = evaluate(globalObject-&gt;globalExec(), globalObject-&gt;globalScopeChain(), makeSource(script.data(), fileName));
</span><span class="lines">@@ -346,12 +346,12 @@
</span><span class="cx"> 
</span><span class="cx">         globalObject-&gt;globalExec()-&gt;clearException();
</span><span class="cx"> 
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">         interpreter-&gt;sampler()-&gt;stop();
</span><span class="cx"> #endif
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     interpreter-&gt;sampler()-&gt;dump(globalObject-&gt;globalExec());
</span><span class="cx">     delete interpreter-&gt;sampler();
</span><span class="cx"> #endif
</span></span></pre></div>
<a id="trunkJavaScriptCoremasmX86Assemblerh"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/masm/X86Assembler.h (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/masm/X86Assembler.h        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/masm/X86Assembler.h        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -278,7 +278,7 @@
</span><span class="cx">         GROUP5_OP_PUSH  = 6,
</span><span class="cx"> 
</span><span class="cx">         GROUP11_MOV = 0,
</span><del>-    } BytecodeID;
</del><ins>+    } OpcodeID;
</ins><span class="cx">     
</span><span class="cx">     static const int MAX_INSTRUCTION_SIZE = 16;
</span><span class="cx"> 
</span><span class="lines">@@ -1230,40 +1230,40 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_opr(BytecodeID bytecode, RegisterID rm)
</del><ins>+    void emitModRm_opr(OpcodeID opcodeID, RegisterID rm)
</ins><span class="cx">     {
</span><span class="cx">         m_buffer-&gt;ensureSpace(MAX_INSTRUCTION_SIZE);
</span><del>-        emitModRm_opr_Unchecked(bytecode, rm);
</del><ins>+        emitModRm_opr_Unchecked(opcodeID, rm);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_opr_Unchecked(BytecodeID bytecode, RegisterID rm)
</del><ins>+    void emitModRm_opr_Unchecked(OpcodeID opcodeID, RegisterID rm)
</ins><span class="cx">     {
</span><del>-        emitModRm_rr_Unchecked(static_cast&lt;RegisterID&gt;(bytecode), rm);
</del><ins>+        emitModRm_rr_Unchecked(static_cast&lt;RegisterID&gt;(opcodeID), rm);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_opm(BytecodeID bytecode, RegisterID base)
</del><ins>+    void emitModRm_opm(OpcodeID opcodeID, RegisterID base)
</ins><span class="cx">     {
</span><del>-        emitModRm_rm(static_cast&lt;RegisterID&gt;(bytecode), base);
</del><ins>+        emitModRm_rm(static_cast&lt;RegisterID&gt;(opcodeID), base);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_opm_Unchecked(BytecodeID bytecode, RegisterID base, int offset)
</del><ins>+    void emitModRm_opm_Unchecked(OpcodeID opcodeID, RegisterID base, int offset)
</ins><span class="cx">     {
</span><del>-        emitModRm_rm_Unchecked(static_cast&lt;RegisterID&gt;(bytecode), base, offset);
</del><ins>+        emitModRm_rm_Unchecked(static_cast&lt;RegisterID&gt;(opcodeID), base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_opm(BytecodeID bytecode, RegisterID base, int offset)
</del><ins>+    void emitModRm_opm(OpcodeID opcodeID, RegisterID base, int offset)
</ins><span class="cx">     {
</span><del>-        emitModRm_rm(static_cast&lt;RegisterID&gt;(bytecode), base, offset);
</del><ins>+        emitModRm_rm(static_cast&lt;RegisterID&gt;(opcodeID), base, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_opm(BytecodeID bytecode, void* addr)
</del><ins>+    void emitModRm_opm(OpcodeID opcodeID, void* addr)
</ins><span class="cx">     {
</span><del>-        emitModRm_rm(static_cast&lt;RegisterID&gt;(bytecode), addr);
</del><ins>+        emitModRm_rm(static_cast&lt;RegisterID&gt;(opcodeID), addr);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><del>-    void emitModRm_opmsib(BytecodeID bytecode, RegisterID base, RegisterID index, int scale, int offset)
</del><ins>+    void emitModRm_opmsib(OpcodeID opcodeID, RegisterID base, RegisterID index, int scale, int offset)
</ins><span class="cx">     {
</span><del>-        emitModRm_rmsib(static_cast&lt;RegisterID&gt;(bytecode), base, index, scale, offset);
</del><ins>+        emitModRm_rmsib(static_cast&lt;RegisterID&gt;(opcodeID), base, index, scale, offset);
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx">     JITCodeBuffer* m_buffer;
</span></span></pre></div>
<a id="trunkJavaScriptCoreparserNodescpp"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/parser/Nodes.cpp (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/parser/Nodes.cpp        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/parser/Nodes.cpp        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -1093,7 +1093,7 @@
</span><span class="cx"> RegisterID* UnaryOpNode::emitBytecode(BytecodeGenerator&amp; generator, RegisterID* dst)
</span><span class="cx"> {
</span><span class="cx">     RegisterID* src = generator.emitNode(m_expr.get());
</span><del>-    return generator.emitUnaryOp(bytecode(), generator.finalDestination(dst), src, m_expr-&gt;resultDescriptor());
</del><ins>+    return generator.emitUnaryOp(opcodeID(), generator.finalDestination(dst), src, m_expr-&gt;resultDescriptor());
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> // ------------------------------ Binary Operation Nodes -----------------------------------
</span><span class="lines">@@ -1111,8 +1111,8 @@
</span><span class="cx"> 
</span><span class="cx"> RegisterID* BinaryOpNode::emitBytecode(BytecodeGenerator&amp; generator, RegisterID* dst)
</span><span class="cx"> {
</span><del>-    BytecodeID bytecode = this-&gt;bytecode();
-    if (bytecode == op_neq) {
</del><ins>+    OpcodeID opcodeID = this-&gt;opcodeID();
+    if (opcodeID == op_neq) {
</ins><span class="cx">         if (m_expr1-&gt;isNull() || m_expr2-&gt;isNull()) {
</span><span class="cx">             RefPtr&lt;RegisterID&gt; src = generator.emitNode(dst, m_expr1-&gt;isNull() ? m_expr2.get() : m_expr1.get());
</span><span class="cx">             return generator.emitUnaryOp(op_neq_null, generator.finalDestination(dst, src.get()), src.get(), ResultType::unknown());
</span><span class="lines">@@ -1121,7 +1121,7 @@
</span><span class="cx"> 
</span><span class="cx">     RefPtr&lt;RegisterID&gt; src1 = generator.emitNodeForLeftHandSide(m_expr1.get(), m_rightHasAssignments, m_expr2-&gt;isPure(generator));
</span><span class="cx">     RegisterID* src2 = generator.emitNode(m_expr2.get());
</span><del>-    return generator.emitBinaryOp(bytecode, generator.finalDestination(dst, src1.get()), src1.get(), src2, OperandTypes(m_expr1-&gt;resultDescriptor(), m_expr2-&gt;resultDescriptor()));
</del><ins>+    return generator.emitBinaryOp(opcodeID, generator.finalDestination(dst, src1.get()), src1.get(), src2, OperandTypes(m_expr1-&gt;resultDescriptor(), m_expr2-&gt;resultDescriptor()));
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> RegisterID* EqualNode::emitBytecode(BytecodeGenerator&amp; generator, RegisterID* dst)
</span><span class="lines">@@ -1147,7 +1147,7 @@
</span><span class="cx"> {
</span><span class="cx">     RefPtr&lt;RegisterID&gt; src1 = generator.emitNodeForLeftHandSide(m_expr1.get(), m_rightHasAssignments, m_expr2-&gt;isPure(generator));
</span><span class="cx">     RegisterID* src2 = generator.emitNode(m_expr2.get());
</span><del>-    return generator.emitBinaryOp(bytecode(), generator.finalDestination(dst, src1.get()), src2, src1.get(), OperandTypes(m_expr2-&gt;resultDescriptor(), m_expr1-&gt;resultDescriptor()));
</del><ins>+    return generator.emitBinaryOp(opcodeID(), generator.finalDestination(dst, src1.get()), src2, src1.get(), OperandTypes(m_expr2-&gt;resultDescriptor(), m_expr1-&gt;resultDescriptor()));
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> RegisterID* ThrowableBinaryOpNode::emitBytecode(BytecodeGenerator&amp; generator, RegisterID* dst)
</span><span class="lines">@@ -1155,7 +1155,7 @@
</span><span class="cx">     RefPtr&lt;RegisterID&gt; src1 = generator.emitNodeForLeftHandSide(m_expr1.get(), m_rightHasAssignments, m_expr2-&gt;isPure(generator));
</span><span class="cx">     RegisterID* src2 = generator.emitNode(m_expr2.get());
</span><span class="cx">     generator.emitExpressionInfo(divot(), startOffset(), endOffset());
</span><del>-    return generator.emitBinaryOp(bytecode(), generator.finalDestination(dst, src1.get()), src1.get(), src2, OperandTypes(m_expr1-&gt;resultDescriptor(), m_expr2-&gt;resultDescriptor()));
</del><ins>+    return generator.emitBinaryOp(opcodeID(), generator.finalDestination(dst, src1.get()), src1.get(), src2, OperandTypes(m_expr1-&gt;resultDescriptor(), m_expr2-&gt;resultDescriptor()));
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> RegisterID* InstanceOfNode::emitBytecode(BytecodeGenerator&amp; generator, RegisterID* dst)
</span><span class="lines">@@ -1248,47 +1248,47 @@
</span><span class="cx"> // FIXME: should this be moved to be a method on BytecodeGenerator?
</span><span class="cx"> static ALWAYS_INLINE RegisterID* emitReadModifyAssignment(BytecodeGenerator&amp; generator, RegisterID* dst, RegisterID* src1, RegisterID* src2, Operator oper, OperandTypes types)
</span><span class="cx"> {
</span><del>-    BytecodeID bytecode;
</del><ins>+    OpcodeID opcodeID;
</ins><span class="cx">     switch (oper) {
</span><span class="cx">         case OpMultEq:
</span><del>-            bytecode = op_mul;
</del><ins>+            opcodeID = op_mul;
</ins><span class="cx">             break;
</span><span class="cx">         case OpDivEq:
</span><del>-            bytecode = op_div;
</del><ins>+            opcodeID = op_div;
</ins><span class="cx">             break;
</span><span class="cx">         case OpPlusEq:
</span><del>-            bytecode = op_add;
</del><ins>+            opcodeID = op_add;
</ins><span class="cx">             break;
</span><span class="cx">         case OpMinusEq:
</span><del>-            bytecode = op_sub;
</del><ins>+            opcodeID = op_sub;
</ins><span class="cx">             break;
</span><span class="cx">         case OpLShift:
</span><del>-            bytecode = op_lshift;
</del><ins>+            opcodeID = op_lshift;
</ins><span class="cx">             break;
</span><span class="cx">         case OpRShift:
</span><del>-            bytecode = op_rshift;
</del><ins>+            opcodeID = op_rshift;
</ins><span class="cx">             break;
</span><span class="cx">         case OpURShift:
</span><del>-            bytecode = op_urshift;
</del><ins>+            opcodeID = op_urshift;
</ins><span class="cx">             break;
</span><span class="cx">         case OpAndEq:
</span><del>-            bytecode = op_bitand;
</del><ins>+            opcodeID = op_bitand;
</ins><span class="cx">             break;
</span><span class="cx">         case OpXOrEq:
</span><del>-            bytecode = op_bitxor;
</del><ins>+            opcodeID = op_bitxor;
</ins><span class="cx">             break;
</span><span class="cx">         case OpOrEq:
</span><del>-            bytecode = op_bitor;
</del><ins>+            opcodeID = op_bitor;
</ins><span class="cx">             break;
</span><span class="cx">         case OpModEq:
</span><del>-            bytecode = op_mod;
</del><ins>+            opcodeID = op_mod;
</ins><span class="cx">             break;
</span><span class="cx">         default:
</span><span class="cx">             ASSERT_NOT_REACHED();
</span><span class="cx">             return dst;
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    return generator.emitBinaryOp(bytecode, dst, src1, src2, types);
</del><ins>+    return generator.emitBinaryOp(opcodeID, dst, src1, src2, types);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> RegisterID* ReadModifyResolveNode::emitBytecode(BytecodeGenerator&amp; generator, RegisterID* dst)
</span><span class="lines">@@ -2389,7 +2389,7 @@
</span><span class="cx">         m_varStack = *varStack;
</span><span class="cx">     if (funcStack)
</span><span class="cx">         m_functionStack = *funcStack;
</span><del>-#if ENABLE(BYTECODE_SAMPLING)
</del><ins>+#if ENABLE(OPCODE_SAMPLING)
</ins><span class="cx">     globalData-&gt;interpreter-&gt;sampler()-&gt;notifyOfScope(this);
</span><span class="cx"> #endif
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkJavaScriptCoreparserNodesh"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/parser/Nodes.h (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/parser/Nodes.h        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/parser/Nodes.h        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -1077,7 +1077,7 @@
</span><span class="cx">         virtual void releaseNodes(NodeReleaser&amp;);
</span><span class="cx"> 
</span><span class="cx">         virtual RegisterID* emitBytecode(BytecodeGenerator&amp;, RegisterID* = 0) JSC_FAST_CALL;
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL = 0;
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL = 0;
</ins><span class="cx"> 
</span><span class="cx">     protected:
</span><span class="cx">         RefPtr&lt;ExpressionNode&gt; m_expr;
</span><span class="lines">@@ -1092,7 +1092,7 @@
</span><span class="cx"> 
</span><span class="cx">         virtual ExpressionNode* stripUnaryPlus() { return m_expr.get(); }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_to_jsnumber; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_to_jsnumber; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class NegateNode : public UnaryOpNode {
</span><span class="lines">@@ -1102,7 +1102,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_negate; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_negate; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class BitwiseNotNode : public UnaryOpNode {
</span><span class="lines">@@ -1112,7 +1112,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_bitnot; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_bitnot; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class LogicalNotNode : public UnaryOpNode {
</span><span class="lines">@@ -1122,7 +1122,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_not; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_not; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class BinaryOpNode : public ExpressionNode {
</span><span class="lines">@@ -1147,7 +1147,7 @@
</span><span class="cx">         virtual void releaseNodes(NodeReleaser&amp;);
</span><span class="cx"> 
</span><span class="cx">         virtual RegisterID* emitBytecode(BytecodeGenerator&amp;, RegisterID* = 0) JSC_FAST_CALL;
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL = 0;
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL = 0;
</ins><span class="cx"> 
</span><span class="cx">     protected:
</span><span class="cx">         RefPtr&lt;ExpressionNode&gt; m_expr1;
</span><span class="lines">@@ -1177,7 +1177,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_mul; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_mul; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class DivNode : public BinaryOpNode {
</span><span class="lines">@@ -1187,7 +1187,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_div; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_div; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class ModNode : public BinaryOpNode {
</span><span class="lines">@@ -1197,7 +1197,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_mod; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_mod; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class AddNode : public BinaryOpNode {
</span><span class="lines">@@ -1207,7 +1207,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_add; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_add; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class SubNode : public BinaryOpNode {
</span><span class="lines">@@ -1217,7 +1217,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_sub; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_sub; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class LeftShiftNode : public BinaryOpNode {
</span><span class="lines">@@ -1227,7 +1227,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_lshift; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_lshift; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class RightShiftNode : public BinaryOpNode {
</span><span class="lines">@@ -1237,7 +1237,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_rshift; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_rshift; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class UnsignedRightShiftNode : public BinaryOpNode {
</span><span class="lines">@@ -1247,7 +1247,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_urshift; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_urshift; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class LessNode : public BinaryOpNode {
</span><span class="lines">@@ -1257,7 +1257,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_less; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_less; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class GreaterNode : public ReverseBinaryOpNode {
</span><span class="lines">@@ -1267,7 +1267,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_less; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_less; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class LessEqNode : public BinaryOpNode {
</span><span class="lines">@@ -1277,7 +1277,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_lesseq; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_lesseq; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class GreaterEqNode : public ReverseBinaryOpNode {
</span><span class="lines">@@ -1287,7 +1287,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_lesseq; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_lesseq; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class ThrowableBinaryOpNode : public BinaryOpNode, public ThrowableExpressionData {
</span><span class="lines">@@ -1310,7 +1310,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_instanceof; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_instanceof; }
</ins><span class="cx"> 
</span><span class="cx">         virtual RegisterID* emitBytecode(BytecodeGenerator&amp;, RegisterID* = 0) JSC_FAST_CALL;
</span><span class="cx">     };
</span><span class="lines">@@ -1322,7 +1322,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_in; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_in; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class EqualNode : public BinaryOpNode {
</span><span class="lines">@@ -1333,7 +1333,7 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         virtual RegisterID* emitBytecode(BytecodeGenerator&amp;, RegisterID* = 0) JSC_FAST_CALL;
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_eq; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_eq; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class NotEqualNode : public BinaryOpNode {
</span><span class="lines">@@ -1343,7 +1343,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_neq; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_neq; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class StrictEqualNode : public BinaryOpNode {
</span><span class="lines">@@ -1354,7 +1354,7 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         virtual RegisterID* emitBytecode(BytecodeGenerator&amp;, RegisterID* = 0) JSC_FAST_CALL;
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_stricteq; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_stricteq; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class NotStrictEqualNode : public BinaryOpNode {
</span><span class="lines">@@ -1364,7 +1364,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_nstricteq; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_nstricteq; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class BitAndNode : public BinaryOpNode {
</span><span class="lines">@@ -1374,7 +1374,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_bitand; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_bitand; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class BitOrNode : public BinaryOpNode {
</span><span class="lines">@@ -1384,7 +1384,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_bitor; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_bitor; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     class BitXOrNode : public BinaryOpNode {
</span><span class="lines">@@ -1394,7 +1394,7 @@
</span><span class="cx">         {
</span><span class="cx">         }
</span><span class="cx"> 
</span><del>-        virtual BytecodeID bytecode() const JSC_FAST_CALL { return op_bitxor; }
</del><ins>+        virtual OpcodeID opcodeID() const JSC_FAST_CALL { return op_bitxor; }
</ins><span class="cx">     };
</span><span class="cx"> 
</span><span class="cx">     /**
</span></span></pre></div>
<a id="trunkJavaScriptCoreruntimeStructureIDcpp"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/runtime/StructureID.cpp (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/runtime/StructureID.cpp        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/runtime/StructureID.cpp        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -497,7 +497,7 @@
</span><span class="cx"> {
</span><span class="cx">     ASSERT(structureID-&gt;m_isDictionary);
</span><span class="cx"> 
</span><del>-    // Since dictionary StructureIDs are not shared, and no bytecodes specialize
</del><ins>+    // Since dictionary StructureIDs are not shared, and no opcodes specialize
</ins><span class="cx">     // for them, we don't need to allocate a new StructureID when transitioning
</span><span class="cx">     // to non-dictionary status.
</span><span class="cx"> 
</span></span></pre></div>
<a id="trunkJavaScriptCorewtfPlatformh"></a>
<div class="modfile"><h4>Modified: trunk/JavaScriptCore/wtf/Platform.h (38427 => 38428)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/JavaScriptCore/wtf/Platform.h        2008-11-15 21:05:23 UTC (rev 38427)
+++ trunk/JavaScriptCore/wtf/Platform.h        2008-11-15 21:37:49 UTC (rev 38428)
</span><span class="lines">@@ -383,20 +383,20 @@
</span><span class="cx"> #define ENABLE_NETSCAPE_PLUGIN_API 1
</span><span class="cx"> #endif
</span><span class="cx"> 
</span><del>-#if !defined(ENABLE_BYTECODE_STATS)
-#define ENABLE_BYTECODE_STATS 0
</del><ins>+#if !defined(ENABLE_OPCODE_STATS)
+#define ENABLE_OPCODE_STATS 0
</ins><span class="cx"> #endif
</span><span class="cx"> 
</span><span class="cx"> #if !defined(ENABLE_CODEBLOCK_SAMPLING)
</span><span class="cx"> #define ENABLE_CODEBLOCK_SAMPLING 0
</span><span class="cx"> #endif
</span><span class="cx"> 
</span><del>-#if ENABLE(CODEBLOCK_SAMPLING) &amp;&amp; !defined(ENABLE_BYTECODE_SAMPLING)
-#define ENABLE_BYTECODE_SAMPLING 1
</del><ins>+#if ENABLE(CODEBLOCK_SAMPLING) &amp;&amp; !defined(ENABLE_OPCODE_SAMPLING)
+#define ENABLE_OPCODE_SAMPLING 1
</ins><span class="cx"> #endif
</span><span class="cx"> 
</span><del>-#if !defined(ENABLE_BYTECODE_SAMPLING)
-#define ENABLE_BYTECODE_SAMPLING 0
</del><ins>+#if !defined(ENABLE_OPCODE_SAMPLING)
+#define ENABLE_OPCODE_SAMPLING 0
</ins><span class="cx"> #endif
</span><span class="cx"> 
</span><span class="cx"> #if !defined(ENABLE_GEOLOCATION)
</span></span></pre>
</div>
</div>

</body>
</html>