<!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>[190230] trunk/Source/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/190230">190230</a></dd>
<dt>Author</dt> <dd>mark.lam@apple.com</dd>
<dt>Date</dt> <dd>2015-09-24 17:17:16 -0700 (Thu, 24 Sep 2015)</dd>
</dl>
<h3>Log Message</h3>
<pre>Remove the use of "Immediate" in JIT function names.
https://bugs.webkit.org/show_bug.cgi?id=149542
Reviewed by Geoffrey Garen.
We will rename the following:
isOperandConstantImmediateDouble => isOperandConstantDouble
isOperandConstantImmediateInt => isOperandConstantInt
isOperandConstantImmediateChar => isOperandConstantChar
getOperandConstantImmediateInt => getOperandConstantInt
getConstantOperandImmediateInt => getOperandConstantInt
emitJumpIfImmediateInteger => emitJumpIfInt
emitJumpIfNotImmediateInteger => emitJumpIfNotInt
emitJumpIfNotImmediateIntegers => emitJumpIfNotInt
emitPatchableJumpIfNotImmediateInteger => emitPatchableJumpIfNotInt
emitJumpSlowCaseIfNotImmediateInteger => emitJumpSlowCaseIfNotInt
emitJumpSlowCaseIfNotImmediateNumber => emitJumpSlowCaseIfNotNumber
emitJumpSlowCaseIfNotImmediateIntegers => emitJumpSlowCaseIfNotInt
emitFastArithReTagImmediate => emitTagInt
emitTagAsBoolImmediate => emitTagBool
emitJumpIfImmediateNumber => emitJumpIfNumber
emitJumpIfNotImmediateNumber => emitJumpIfNotNumber
emitFastArithImmToInt - Deleted because this is an empty function.
emitFastArithIntToImmNoCheck => emitTagInt
emitPutImmediateToCallFrameHeader => emitPutToCallFrameHeader
This is purely a refactoring patch to do the renaming. There is no behavior
change.
* dfg/DFGJITCompiler.cpp:
(JSC::DFG::JITCompiler::compileEntry):
(JSC::DFG::JITCompiler::compileSetupRegistersForEntry):
* jit/AssemblyHelpers.h:
(JSC::AssemblyHelpers::emitPutToCallFrameHeader):
(JSC::AssemblyHelpers::emitPutImmediateToCallFrameHeader): Deleted.
* jit/JIT.cpp:
(JSC::JIT::privateCompile):
* jit/JIT.h:
(JSC::JIT::emitStoreCell):
(JSC::JIT::getSlowCase):
* jit/JITArithmetic.cpp:
(JSC::JIT::emit_op_negate):
(JSC::JIT::emit_op_lshift):
(JSC::JIT::emit_op_rshift):
(JSC::JIT::emitSlow_op_rshift):
(JSC::JIT::emit_op_urshift):
(JSC::JIT::emitSlow_op_urshift):
(JSC::JIT::emit_op_unsigned):
(JSC::JIT::emit_compareAndJump):
(JSC::JIT::emit_compareAndJumpSlow):
(JSC::JIT::emit_op_bitand):
(JSC::JIT::emit_op_inc):
(JSC::JIT::emit_op_dec):
(JSC::JIT::emit_op_mod):
(JSC::JIT::compileBinaryArithOp):
(JSC::JIT::compileBinaryArithOpSlowCase):
(JSC::JIT::emit_op_add):
(JSC::JIT::emitSlow_op_add):
(JSC::JIT::emit_op_mul):
(JSC::JIT::emitSlow_op_mul):
(JSC::JIT::emit_op_div):
(JSC::JIT::emitSlow_op_div):
* jit/JITArithmetic32_64.cpp:
(JSC::JIT::emit_compareAndJump):
(JSC::JIT::emit_compareAndJumpSlow):
(JSC::JIT::emit_op_lshift):
(JSC::JIT::emitSlow_op_lshift):
(JSC::JIT::emitRightShift):
(JSC::JIT::emitRightShiftSlowCase):
(JSC::JIT::emit_op_bitand):
(JSC::JIT::emitSlow_op_bitand):
(JSC::JIT::emit_op_bitor):
(JSC::JIT::emitSlow_op_bitor):
(JSC::JIT::emit_op_bitxor):
(JSC::JIT::emitSlow_op_bitxor):
(JSC::JIT::emit_op_add):
(JSC::JIT::emitSlow_op_add):
(JSC::JIT::emit_op_sub):
(JSC::JIT::emitSlow_op_sub):
* jit/JITInlines.h:
(JSC::JIT::emitArrayStorageGetByVal):
(JSC::JIT::isOperandConstantDouble):
(JSC::JIT::isOperandConstantChar):
(JSC::JIT::emitJumpSlowCaseIfNotJSCell):
(JSC::JIT::isOperandConstantInt):
(JSC::JIT::getOperandConstantInt):
(JSC::JIT::emitGetVirtualRegisters):
(JSC::JIT::emitLoadInt32ToDouble):
(JSC::JIT::emitJumpIfInt):
(JSC::JIT::emitJumpIfNotInt):
(JSC::JIT::emitPatchableJumpIfNotInt):
(JSC::JIT::emitJumpSlowCaseIfNotInt):
(JSC::JIT::emitJumpSlowCaseIfNotNumber):
(JSC::JIT::emitTagBool):
(JSC::JIT::isOperandConstantImmediateDouble): Deleted.
(JSC::JIT::isOperandConstantImmediateChar): Deleted.
(JSC::JIT::isOperandConstantImmediateInt): Deleted.
(JSC::JIT::getOperandConstantImmediateInt): Deleted.
(JSC::JIT::getConstantOperandImmediateInt): Deleted.
(JSC::JIT::emitJumpIfImmediateInteger): Deleted.
(JSC::JIT::emitJumpIfNotImmediateInteger): Deleted.
(JSC::JIT::emitPatchableJumpIfNotImmediateInteger): Deleted.
(JSC::JIT::emitJumpIfNotImmediateIntegers): Deleted.
(JSC::JIT::emitJumpSlowCaseIfNotImmediateInteger): Deleted.
(JSC::JIT::emitJumpSlowCaseIfNotImmediateIntegers): Deleted.
(JSC::JIT::emitJumpSlowCaseIfNotImmediateNumber): Deleted.
(JSC::JIT::emitFastArithReTagImmediate): Deleted.
(JSC::JIT::emitTagAsBoolImmediate): Deleted.
* jit/JITOpcodes.cpp:
(JSC::JIT::emit_op_is_undefined):
(JSC::JIT::emit_op_is_boolean):
(JSC::JIT::emit_op_is_number):
(JSC::JIT::emit_op_is_string):
(JSC::JIT::emit_op_is_object):
(JSC::JIT::emit_op_jfalse):
(JSC::JIT::emit_op_eq):
(JSC::JIT::emit_op_jtrue):
(JSC::JIT::emit_op_neq):
(JSC::JIT::emit_op_bitxor):
(JSC::JIT::emit_op_bitor):
(JSC::JIT::compileOpStrictEq):
(JSC::JIT::emit_op_to_number):
(JSC::JIT::emit_op_eq_null):
(JSC::JIT::emit_op_neq_null):
(JSC::JIT::emitSlow_op_eq):
(JSC::JIT::emitSlow_op_neq):
(JSC::JIT::emit_op_profile_type):
* jit/JITOpcodes32_64.cpp:
(JSC::JIT::privateCompileCTINativeCall):
* jit/JITPropertyAccess.cpp:
(JSC::JIT::emit_op_get_by_val):
(JSC::JIT::emit_op_put_by_val):
(JSC::JIT::emitGenericContiguousPutByVal):
(JSC::JIT::emit_op_put_by_id):
(JSC::JIT::emitIntTypedArrayPutByVal):
(JSC::JIT::emitFloatTypedArrayPutByVal):
* jit/JSInterfaceJIT.h:
(JSC::JSInterfaceJIT::emitJumpIfNotJSCell):
(JSC::JSInterfaceJIT::emitJumpIfNumber):
(JSC::JSInterfaceJIT::emitJumpIfNotNumber):
(JSC::JSInterfaceJIT::emitLoadDouble):
(JSC::JSInterfaceJIT::emitTagInt):
(JSC::JSInterfaceJIT::emitPutToCallFrameHeader):
(JSC::JSInterfaceJIT::emitJumpIfImmediateNumber): Deleted.
(JSC::JSInterfaceJIT::emitJumpIfNotImmediateNumber): Deleted.
(JSC::JSInterfaceJIT::emitFastArithImmToInt): Deleted.
(JSC::JSInterfaceJIT::emitFastArithIntToImmNoCheck): Deleted.
(JSC::JSInterfaceJIT::emitPutImmediateToCallFrameHeader): Deleted.
* jit/ThunkGenerators.cpp:
(JSC::nativeForGenerator):
* wasm/WASMFunctionCompiler.h:
(JSC::WASMFunctionCompiler::startFunction):
(JSC::WASMFunctionCompiler::endFunction):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGJITCompilercpp">trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitAssemblyHelpersh">trunk/Source/JavaScriptCore/jit/AssemblyHelpers.h</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITcpp">trunk/Source/JavaScriptCore/jit/JIT.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITh">trunk/Source/JavaScriptCore/jit/JIT.h</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITArithmeticcpp">trunk/Source/JavaScriptCore/jit/JITArithmetic.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITArithmetic32_64cpp">trunk/Source/JavaScriptCore/jit/JITArithmetic32_64.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITInlinesh">trunk/Source/JavaScriptCore/jit/JITInlines.h</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITOpcodescpp">trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITOpcodes32_64cpp">trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITPropertyAccesscpp">trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJSInterfaceJITh">trunk/Source/JavaScriptCore/jit/JSInterfaceJIT.h</a></li>
<li><a href="#trunkSourceJavaScriptCorejitThunkGeneratorscpp">trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorewasmWASMFunctionCompilerh">trunk/Source/JavaScriptCore/wasm/WASMFunctionCompiler.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (190229 => 190230)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2015-09-24 23:33:34 UTC (rev 190229)
+++ trunk/Source/JavaScriptCore/ChangeLog 2015-09-25 00:17:16 UTC (rev 190230)
</span><span class="lines">@@ -1,3 +1,161 @@
</span><ins>+2015-09-24 Mark Lam <mark.lam@apple.com>
+
+ Remove the use of "Immediate" in JIT function names.
+ https://bugs.webkit.org/show_bug.cgi?id=149542
+
+ Reviewed by Geoffrey Garen.
+
+ We will rename the following:
+ isOperandConstantImmediateDouble => isOperandConstantDouble
+ isOperandConstantImmediateInt => isOperandConstantInt
+ isOperandConstantImmediateChar => isOperandConstantChar
+
+ getOperandConstantImmediateInt => getOperandConstantInt
+ getConstantOperandImmediateInt => getOperandConstantInt
+
+ emitJumpIfImmediateInteger => emitJumpIfInt
+ emitJumpIfNotImmediateInteger => emitJumpIfNotInt
+ emitJumpIfNotImmediateIntegers => emitJumpIfNotInt
+ emitPatchableJumpIfNotImmediateInteger => emitPatchableJumpIfNotInt
+ emitJumpSlowCaseIfNotImmediateInteger => emitJumpSlowCaseIfNotInt
+ emitJumpSlowCaseIfNotImmediateNumber => emitJumpSlowCaseIfNotNumber
+ emitJumpSlowCaseIfNotImmediateIntegers => emitJumpSlowCaseIfNotInt
+ emitFastArithReTagImmediate => emitTagInt
+ emitTagAsBoolImmediate => emitTagBool
+ emitJumpIfImmediateNumber => emitJumpIfNumber
+ emitJumpIfNotImmediateNumber => emitJumpIfNotNumber
+ emitFastArithImmToInt - Deleted because this is an empty function.
+ emitFastArithIntToImmNoCheck => emitTagInt
+ emitPutImmediateToCallFrameHeader => emitPutToCallFrameHeader
+
+ This is purely a refactoring patch to do the renaming. There is no behavior
+ change.
+
+ * dfg/DFGJITCompiler.cpp:
+ (JSC::DFG::JITCompiler::compileEntry):
+ (JSC::DFG::JITCompiler::compileSetupRegistersForEntry):
+ * jit/AssemblyHelpers.h:
+ (JSC::AssemblyHelpers::emitPutToCallFrameHeader):
+ (JSC::AssemblyHelpers::emitPutImmediateToCallFrameHeader): Deleted.
+ * jit/JIT.cpp:
+ (JSC::JIT::privateCompile):
+ * jit/JIT.h:
+ (JSC::JIT::emitStoreCell):
+ (JSC::JIT::getSlowCase):
+ * jit/JITArithmetic.cpp:
+ (JSC::JIT::emit_op_negate):
+ (JSC::JIT::emit_op_lshift):
+ (JSC::JIT::emit_op_rshift):
+ (JSC::JIT::emitSlow_op_rshift):
+ (JSC::JIT::emit_op_urshift):
+ (JSC::JIT::emitSlow_op_urshift):
+ (JSC::JIT::emit_op_unsigned):
+ (JSC::JIT::emit_compareAndJump):
+ (JSC::JIT::emit_compareAndJumpSlow):
+ (JSC::JIT::emit_op_bitand):
+ (JSC::JIT::emit_op_inc):
+ (JSC::JIT::emit_op_dec):
+ (JSC::JIT::emit_op_mod):
+ (JSC::JIT::compileBinaryArithOp):
+ (JSC::JIT::compileBinaryArithOpSlowCase):
+ (JSC::JIT::emit_op_add):
+ (JSC::JIT::emitSlow_op_add):
+ (JSC::JIT::emit_op_mul):
+ (JSC::JIT::emitSlow_op_mul):
+ (JSC::JIT::emit_op_div):
+ (JSC::JIT::emitSlow_op_div):
+ * jit/JITArithmetic32_64.cpp:
+ (JSC::JIT::emit_compareAndJump):
+ (JSC::JIT::emit_compareAndJumpSlow):
+ (JSC::JIT::emit_op_lshift):
+ (JSC::JIT::emitSlow_op_lshift):
+ (JSC::JIT::emitRightShift):
+ (JSC::JIT::emitRightShiftSlowCase):
+ (JSC::JIT::emit_op_bitand):
+ (JSC::JIT::emitSlow_op_bitand):
+ (JSC::JIT::emit_op_bitor):
+ (JSC::JIT::emitSlow_op_bitor):
+ (JSC::JIT::emit_op_bitxor):
+ (JSC::JIT::emitSlow_op_bitxor):
+ (JSC::JIT::emit_op_add):
+ (JSC::JIT::emitSlow_op_add):
+ (JSC::JIT::emit_op_sub):
+ (JSC::JIT::emitSlow_op_sub):
+ * jit/JITInlines.h:
+ (JSC::JIT::emitArrayStorageGetByVal):
+ (JSC::JIT::isOperandConstantDouble):
+ (JSC::JIT::isOperandConstantChar):
+ (JSC::JIT::emitJumpSlowCaseIfNotJSCell):
+ (JSC::JIT::isOperandConstantInt):
+ (JSC::JIT::getOperandConstantInt):
+ (JSC::JIT::emitGetVirtualRegisters):
+ (JSC::JIT::emitLoadInt32ToDouble):
+ (JSC::JIT::emitJumpIfInt):
+ (JSC::JIT::emitJumpIfNotInt):
+ (JSC::JIT::emitPatchableJumpIfNotInt):
+ (JSC::JIT::emitJumpSlowCaseIfNotInt):
+ (JSC::JIT::emitJumpSlowCaseIfNotNumber):
+ (JSC::JIT::emitTagBool):
+ (JSC::JIT::isOperandConstantImmediateDouble): Deleted.
+ (JSC::JIT::isOperandConstantImmediateChar): Deleted.
+ (JSC::JIT::isOperandConstantImmediateInt): Deleted.
+ (JSC::JIT::getOperandConstantImmediateInt): Deleted.
+ (JSC::JIT::getConstantOperandImmediateInt): Deleted.
+ (JSC::JIT::emitJumpIfImmediateInteger): Deleted.
+ (JSC::JIT::emitJumpIfNotImmediateInteger): Deleted.
+ (JSC::JIT::emitPatchableJumpIfNotImmediateInteger): Deleted.
+ (JSC::JIT::emitJumpIfNotImmediateIntegers): Deleted.
+ (JSC::JIT::emitJumpSlowCaseIfNotImmediateInteger): Deleted.
+ (JSC::JIT::emitJumpSlowCaseIfNotImmediateIntegers): Deleted.
+ (JSC::JIT::emitJumpSlowCaseIfNotImmediateNumber): Deleted.
+ (JSC::JIT::emitFastArithReTagImmediate): Deleted.
+ (JSC::JIT::emitTagAsBoolImmediate): Deleted.
+ * jit/JITOpcodes.cpp:
+ (JSC::JIT::emit_op_is_undefined):
+ (JSC::JIT::emit_op_is_boolean):
+ (JSC::JIT::emit_op_is_number):
+ (JSC::JIT::emit_op_is_string):
+ (JSC::JIT::emit_op_is_object):
+ (JSC::JIT::emit_op_jfalse):
+ (JSC::JIT::emit_op_eq):
+ (JSC::JIT::emit_op_jtrue):
+ (JSC::JIT::emit_op_neq):
+ (JSC::JIT::emit_op_bitxor):
+ (JSC::JIT::emit_op_bitor):
+ (JSC::JIT::compileOpStrictEq):
+ (JSC::JIT::emit_op_to_number):
+ (JSC::JIT::emit_op_eq_null):
+ (JSC::JIT::emit_op_neq_null):
+ (JSC::JIT::emitSlow_op_eq):
+ (JSC::JIT::emitSlow_op_neq):
+ (JSC::JIT::emit_op_profile_type):
+ * jit/JITOpcodes32_64.cpp:
+ (JSC::JIT::privateCompileCTINativeCall):
+ * jit/JITPropertyAccess.cpp:
+ (JSC::JIT::emit_op_get_by_val):
+ (JSC::JIT::emit_op_put_by_val):
+ (JSC::JIT::emitGenericContiguousPutByVal):
+ (JSC::JIT::emit_op_put_by_id):
+ (JSC::JIT::emitIntTypedArrayPutByVal):
+ (JSC::JIT::emitFloatTypedArrayPutByVal):
+ * jit/JSInterfaceJIT.h:
+ (JSC::JSInterfaceJIT::emitJumpIfNotJSCell):
+ (JSC::JSInterfaceJIT::emitJumpIfNumber):
+ (JSC::JSInterfaceJIT::emitJumpIfNotNumber):
+ (JSC::JSInterfaceJIT::emitLoadDouble):
+ (JSC::JSInterfaceJIT::emitTagInt):
+ (JSC::JSInterfaceJIT::emitPutToCallFrameHeader):
+ (JSC::JSInterfaceJIT::emitJumpIfImmediateNumber): Deleted.
+ (JSC::JSInterfaceJIT::emitJumpIfNotImmediateNumber): Deleted.
+ (JSC::JSInterfaceJIT::emitFastArithImmToInt): Deleted.
+ (JSC::JSInterfaceJIT::emitFastArithIntToImmNoCheck): Deleted.
+ (JSC::JSInterfaceJIT::emitPutImmediateToCallFrameHeader): Deleted.
+ * jit/ThunkGenerators.cpp:
+ (JSC::nativeForGenerator):
+ * wasm/WASMFunctionCompiler.h:
+ (JSC::WASMFunctionCompiler::startFunction):
+ (JSC::WASMFunctionCompiler::endFunction):
+
</ins><span class="cx"> 2015-09-24 Michael Saboff <msaboff@apple.com>
</span><span class="cx">
</span><span class="cx"> [ES6] Implement tail calls in the DFG
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGJITCompilercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp (190229 => 190230)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp 2015-09-24 23:33:34 UTC (rev 190229)
+++ trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp 2015-09-25 00:17:16 UTC (rev 190230)
</span><span class="lines">@@ -109,7 +109,7 @@
</span><span class="cx"> // check) which will be dependent on stack layout. (We'd need to account for this in
</span><span class="cx"> // both normal return code and when jumping to an exception handler).
</span><span class="cx"> emitFunctionPrologue();
</span><del>- emitPutImmediateToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);
</del><ins>+ emitPutToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void JITCompiler::compileSetupRegistersForEntry()
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitAssemblyHelpersh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/AssemblyHelpers.h (190229 => 190230)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/AssemblyHelpers.h 2015-09-24 23:33:34 UTC (rev 190229)
+++ trunk/Source/JavaScriptCore/jit/AssemblyHelpers.h 2015-09-25 00:17:16 UTC (rev 190230)
</span><span class="lines">@@ -479,7 +479,7 @@
</span><span class="cx"> storePtr(from, Address(GPRInfo::callFrameRegister, entry * sizeof(Register)));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void emitPutImmediateToCallFrameHeader(void* value, JSStack::CallFrameHeaderEntry entry)
</del><ins>+ void emitPutToCallFrameHeader(void* value, JSStack::CallFrameHeaderEntry entry)
</ins><span class="cx"> {
</span><span class="cx"> storePtr(TrustedImmPtr(value), Address(GPRInfo::callFrameRegister, entry * sizeof(Register)));
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JIT.cpp (190229 => 190230)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JIT.cpp 2015-09-24 23:33:34 UTC (rev 190229)
+++ trunk/Source/JavaScriptCore/jit/JIT.cpp 2015-09-25 00:17:16 UTC (rev 190230)
</span><span class="lines">@@ -510,7 +510,7 @@
</span><span class="cx"> nop();
</span><span class="cx">
</span><span class="cx"> emitFunctionPrologue();
</span><del>- emitPutImmediateToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);
</del><ins>+ emitPutToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);
</ins><span class="cx">
</span><span class="cx"> Label beginLabel(this);
</span><span class="cx">
</span><span class="lines">@@ -566,7 +566,7 @@
</span><span class="cx"> arityCheck = label();
</span><span class="cx"> store8(TrustedImm32(0), &m_codeBlock->m_shouldAlwaysBeInlined);
</span><span class="cx"> emitFunctionPrologue();
</span><del>- emitPutImmediateToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);
</del><ins>+ emitPutToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);
</ins><span class="cx">
</span><span class="cx"> load32(payloadFor(JSStack::ArgumentCount), regT1);
</span><span class="cx"> branch32(AboveOrEqual, regT1, TrustedImm32(m_codeBlock->m_numParameters)).linkTo(beginLabel, this);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JIT.h (190229 => 190230)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JIT.h 2015-09-24 23:33:34 UTC (rev 190229)
+++ trunk/Source/JavaScriptCore/jit/JIT.h 2015-09-25 00:17:16 UTC (rev 190230)
</span><span class="lines">@@ -323,7 +323,7 @@
</span><span class="cx">
</span><span class="cx"> enum CompileOpStrictEqType { OpStrictEq, OpNStrictEq };
</span><span class="cx"> void compileOpStrictEq(Instruction* instruction, CompileOpStrictEqType type);
</span><del>- bool isOperandConstantImmediateDouble(int src);
</del><ins>+ bool isOperandConstantDouble(int src);
</ins><span class="cx">
</span><span class="cx"> void emitLoadDouble(int index, FPRegisterID value);
</span><span class="cx"> void emitLoadInt32ToDouble(int index, FPRegisterID value);
</span><span class="lines">@@ -401,7 +401,7 @@
</span><span class="cx"> enum FinalObjectMode { MayBeFinal, KnownNotFinal };
</span><span class="cx">
</span><span class="cx"> #if USE(JSVALUE32_64)
</span><del>- bool getOperandConstantImmediateInt(int op1, int op2, int& op, int32_t& constant);
</del><ins>+ bool getOperandConstantInt(int op1, int op2, int& op, int32_t& constant);
</ins><span class="cx">
</span><span class="cx"> void emitLoadTag(int index, RegisterID tag);
</span><span class="cx"> void emitLoadPayload(int index, RegisterID payload);
</span><span class="lines">@@ -448,24 +448,22 @@
</span><span class="cx"> emitPutVirtualRegister(dst, payload);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- int32_t getConstantOperandImmediateInt(int src);
</del><ins>+ int32_t getOperandConstantInt(int src);
</ins><span class="cx">
</span><span class="cx"> Jump emitJumpIfJSCell(RegisterID);
</span><span class="cx"> Jump emitJumpIfBothJSCells(RegisterID, RegisterID, RegisterID);
</span><span class="cx"> void emitJumpSlowCaseIfJSCell(RegisterID);
</span><span class="cx"> void emitJumpSlowCaseIfNotJSCell(RegisterID);
</span><span class="cx"> void emitJumpSlowCaseIfNotJSCell(RegisterID, int VReg);
</span><del>- Jump emitJumpIfImmediateInteger(RegisterID);
- Jump emitJumpIfNotImmediateInteger(RegisterID);
- Jump emitJumpIfNotImmediateIntegers(RegisterID, RegisterID, RegisterID);
- PatchableJump emitPatchableJumpIfNotImmediateInteger(RegisterID);
- void emitJumpSlowCaseIfNotImmediateInteger(RegisterID);
- void emitJumpSlowCaseIfNotImmediateNumber(RegisterID);
- void emitJumpSlowCaseIfNotImmediateIntegers(RegisterID, RegisterID, RegisterID);
</del><ins>+ Jump emitJumpIfInt(RegisterID);
+ Jump emitJumpIfNotInt(RegisterID);
+ Jump emitJumpIfNotInt(RegisterID, RegisterID, RegisterID scratch);
+ PatchableJump emitPatchableJumpIfNotInt(RegisterID);
+ void emitJumpSlowCaseIfNotInt(RegisterID);
+ void emitJumpSlowCaseIfNotNumber(RegisterID);
+ void emitJumpSlowCaseIfNotInt(RegisterID, RegisterID, RegisterID scratch);
</ins><span class="cx">
</span><del>- void emitFastArithReTagImmediate(RegisterID src, RegisterID dest);
-
- void emitTagAsBoolImmediate(RegisterID reg);
</del><ins>+ void emitTagBool(RegisterID);
</ins><span class="cx"> void compileBinaryArithOp(OpcodeID, int dst, int src1, int src2, OperandTypes opi);
</span><span class="cx"> void compileBinaryArithOpSlowCase(Instruction*, OpcodeID, Vector<SlowCaseEntry>::iterator&, int dst, int src1, int src2, OperandTypes, bool op1HasImmediateIntFastCase, bool op2HasImmediateIntFastCase);
</span><span class="cx">
</span><span class="lines">@@ -692,8 +690,8 @@
</span><span class="cx"> void emitPutIntToCallFrameHeader(RegisterID from, JSStack::CallFrameHeaderEntry);
</span><span class="cx">
</span><span class="cx"> JSValue getConstantOperand(int src);
</span><del>- bool isOperandConstantImmediateInt(int src);
- bool isOperandConstantImmediateChar(int src);
</del><ins>+ bool isOperandConstantInt(int src);
+ bool isOperandConstantChar(int src);
</ins><span class="cx">
</span><span class="cx"> Jump getSlowCase(Vector<SlowCaseEntry>::iterator& iter)
</span><span class="cx"> {
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITArithmeticcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITArithmetic.cpp (190229 => 190230)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITArithmetic.cpp 2015-09-24 23:33:34 UTC (rev 190229)
+++ trunk/Source/JavaScriptCore/jit/JITArithmetic.cpp 2015-09-25 00:17:16 UTC (rev 190230)
</span><span class="lines">@@ -196,15 +196,15 @@
</span><span class="cx">
</span><span class="cx"> emitGetVirtualRegister(src, regT0);
</span><span class="cx">
</span><del>- Jump srcNotInt = emitJumpIfNotImmediateInteger(regT0);
</del><ins>+ Jump srcNotInt = emitJumpIfNotInt(regT0);
</ins><span class="cx"> addSlowCase(branchTest32(Zero, regT0, TrustedImm32(0x7fffffff)));
</span><span class="cx"> neg32(regT0);
</span><del>- emitFastArithReTagImmediate(regT0, regT0);
</del><ins>+ emitTagInt(regT0, regT0);
</ins><span class="cx">
</span><span class="cx"> Jump end = jump();
</span><span class="cx">
</span><span class="cx"> srcNotInt.link(this);
</span><del>- emitJumpSlowCaseIfNotImmediateNumber(regT0);
</del><ins>+ emitJumpSlowCaseIfNotNumber(regT0);
</ins><span class="cx">
</span><span class="cx"> move(TrustedImm64((int64_t)0x8000000000000000ull), regT1);
</span><span class="cx"> xor64(regT1, regT0);
</span><span class="lines">@@ -229,13 +229,11 @@
</span><span class="cx"> int op2 = currentInstruction[3].u.operand;
</span><span class="cx">
</span><span class="cx"> emitGetVirtualRegisters(op1, regT0, op2, regT2);
</span><del>- // FIXME: would we be better using 'emitJumpSlowCaseIfNotImmediateIntegers'? - we *probably* ought to be consistent.
- emitJumpSlowCaseIfNotImmediateInteger(regT0);
- emitJumpSlowCaseIfNotImmediateInteger(regT2);
- emitFastArithImmToInt(regT0);
- emitFastArithImmToInt(regT2);
</del><ins>+ // FIXME: would we be better using a 'emitJumpSlowCaseIfNotInt' that tests both values at once? - we *probably* ought to be consistent.
+ emitJumpSlowCaseIfNotInt(regT0);
+ emitJumpSlowCaseIfNotInt(regT2);
</ins><span class="cx"> lshift32(regT2, regT0);
</span><del>- emitFastArithReTagImmediate(regT0, regT0);
</del><ins>+ emitTagInt(regT0, regT0);
</ins><span class="cx"> emitPutVirtualRegister(result);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -253,32 +251,31 @@
</span><span class="cx"> int op1 = currentInstruction[2].u.operand;
</span><span class="cx"> int op2 = currentInstruction[3].u.operand;
</span><span class="cx">
</span><del>- if (isOperandConstantImmediateInt(op2)) {
- // isOperandConstantImmediateInt(op2) => 1 SlowCase
</del><ins>+ if (isOperandConstantInt(op2)) {
+ // isOperandConstantInt(op2) => 1 SlowCase
</ins><span class="cx"> emitGetVirtualRegister(op1, regT0);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
</ins><span class="cx"> // Mask with 0x1f as per ecma-262 11.7.2 step 7.
</span><del>- rshift32(Imm32(getConstantOperandImmediateInt(op2) & 0x1f), regT0);
</del><ins>+ rshift32(Imm32(getOperandConstantInt(op2) & 0x1f), regT0);
</ins><span class="cx"> } else {
</span><span class="cx"> emitGetVirtualRegisters(op1, regT0, op2, regT2);
</span><span class="cx"> if (supportsFloatingPointTruncate()) {
</span><del>- Jump lhsIsInt = emitJumpIfImmediateInteger(regT0);
</del><ins>+ Jump lhsIsInt = emitJumpIfInt(regT0);
</ins><span class="cx"> // supportsFloatingPoint() && USE(JSVALUE64) => 3 SlowCases
</span><del>- addSlowCase(emitJumpIfNotImmediateNumber(regT0));
</del><ins>+ addSlowCase(emitJumpIfNotNumber(regT0));
</ins><span class="cx"> add64(tagTypeNumberRegister, regT0);
</span><span class="cx"> move64ToDouble(regT0, fpRegT0);
</span><span class="cx"> addSlowCase(branchTruncateDoubleToInt32(fpRegT0, regT0));
</span><span class="cx"> lhsIsInt.link(this);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT2);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT2);
</ins><span class="cx"> } else {
</span><span class="cx"> // !supportsFloatingPoint() => 2 SlowCases
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
- emitJumpSlowCaseIfNotImmediateInteger(regT2);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
+ emitJumpSlowCaseIfNotInt(regT2);
</ins><span class="cx"> }
</span><del>- emitFastArithImmToInt(regT2);
</del><span class="cx"> rshift32(regT2, regT0);
</span><span class="cx"> }
</span><del>- emitFastArithIntToImmNoCheck(regT0, regT0);
</del><ins>+ emitTagInt(regT0, regT0);
</ins><span class="cx"> emitPutVirtualRegister(result);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -286,7 +283,7 @@
</span><span class="cx"> {
</span><span class="cx"> int op2 = currentInstruction[3].u.operand;
</span><span class="cx">
</span><del>- if (isOperandConstantImmediateInt(op2))
</del><ins>+ if (isOperandConstantInt(op2))
</ins><span class="cx"> linkSlowCase(iter);
</span><span class="cx">
</span><span class="cx"> else {
</span><span class="lines">@@ -310,32 +307,31 @@
</span><span class="cx"> int op1 = currentInstruction[2].u.operand;
</span><span class="cx"> int op2 = currentInstruction[3].u.operand;
</span><span class="cx">
</span><del>- if (isOperandConstantImmediateInt(op2)) {
- // isOperandConstantImmediateInt(op2) => 1 SlowCase
</del><ins>+ if (isOperandConstantInt(op2)) {
+ // isOperandConstantInt(op2) => 1 SlowCase
</ins><span class="cx"> emitGetVirtualRegister(op1, regT0);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
</ins><span class="cx"> // Mask with 0x1f as per ecma-262 11.7.2 step 7.
</span><del>- urshift32(Imm32(getConstantOperandImmediateInt(op2) & 0x1f), regT0);
</del><ins>+ urshift32(Imm32(getOperandConstantInt(op2) & 0x1f), regT0);
</ins><span class="cx"> } else {
</span><span class="cx"> emitGetVirtualRegisters(op1, regT0, op2, regT2);
</span><span class="cx"> if (supportsFloatingPointTruncate()) {
</span><del>- Jump lhsIsInt = emitJumpIfImmediateInteger(regT0);
</del><ins>+ Jump lhsIsInt = emitJumpIfInt(regT0);
</ins><span class="cx"> // supportsFloatingPoint() && USE(JSVALUE64) => 3 SlowCases
</span><del>- addSlowCase(emitJumpIfNotImmediateNumber(regT0));
</del><ins>+ addSlowCase(emitJumpIfNotNumber(regT0));
</ins><span class="cx"> add64(tagTypeNumberRegister, regT0);
</span><span class="cx"> move64ToDouble(regT0, fpRegT0);
</span><span class="cx"> addSlowCase(branchTruncateDoubleToInt32(fpRegT0, regT0));
</span><span class="cx"> lhsIsInt.link(this);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT2);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT2);
</ins><span class="cx"> } else {
</span><span class="cx"> // !supportsFloatingPoint() => 2 SlowCases
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
- emitJumpSlowCaseIfNotImmediateInteger(regT2);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
+ emitJumpSlowCaseIfNotInt(regT2);
</ins><span class="cx"> }
</span><del>- emitFastArithImmToInt(regT2);
</del><span class="cx"> urshift32(regT2, regT0);
</span><span class="cx"> }
</span><del>- emitFastArithIntToImmNoCheck(regT0, regT0);
</del><ins>+ emitTagInt(regT0, regT0);
</ins><span class="cx"> emitPutVirtualRegister(result);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -343,7 +339,7 @@
</span><span class="cx"> {
</span><span class="cx"> int op2 = currentInstruction[3].u.operand;
</span><span class="cx">
</span><del>- if (isOperandConstantImmediateInt(op2))
</del><ins>+ if (isOperandConstantInt(op2))
</ins><span class="cx"> linkSlowCase(iter);
</span><span class="cx">
</span><span class="cx"> else {
</span><span class="lines">@@ -367,9 +363,9 @@
</span><span class="cx"> int op1 = currentInstruction[2].u.operand;
</span><span class="cx">
</span><span class="cx"> emitGetVirtualRegister(op1, regT0);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
</ins><span class="cx"> addSlowCase(branch32(LessThan, regT0, TrustedImm32(0)));
</span><del>- emitFastArithReTagImmediate(regT0, regT0);
</del><ins>+ emitTagInt(regT0, regT0);
</ins><span class="cx"> emitPutVirtualRegister(result, regT0);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -389,7 +385,7 @@
</span><span class="cx"> // - constant int immediate to int immediate
</span><span class="cx"> // - int immediate to int immediate
</span><span class="cx">
</span><del>- if (isOperandConstantImmediateChar(op1)) {
</del><ins>+ if (isOperandConstantChar(op1)) {
</ins><span class="cx"> emitGetVirtualRegister(op2, regT0);
</span><span class="cx"> addSlowCase(emitJumpIfNotJSCell(regT0));
</span><span class="cx"> JumpList failures;
</span><span class="lines">@@ -398,7 +394,7 @@
</span><span class="cx"> addJump(branch32(commute(condition), regT0, Imm32(asString(getConstantOperand(op1))->tryGetValue()[0])), target);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (isOperandConstantImmediateChar(op2)) {
</del><ins>+ if (isOperandConstantChar(op2)) {
</ins><span class="cx"> emitGetVirtualRegister(op1, regT0);
</span><span class="cx"> addSlowCase(emitJumpIfNotJSCell(regT0));
</span><span class="cx"> JumpList failures;
</span><span class="lines">@@ -407,20 +403,20 @@
</span><span class="cx"> addJump(branch32(condition, regT0, Imm32(asString(getConstantOperand(op2))->tryGetValue()[0])), target);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (isOperandConstantImmediateInt(op2)) {
</del><ins>+ if (isOperandConstantInt(op2)) {
</ins><span class="cx"> emitGetVirtualRegister(op1, regT0);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
- int32_t op2imm = getConstantOperandImmediateInt(op2);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
+ int32_t op2imm = getOperandConstantInt(op2);
</ins><span class="cx"> addJump(branch32(condition, regT0, Imm32(op2imm)), target);
</span><del>- } else if (isOperandConstantImmediateInt(op1)) {
</del><ins>+ } else if (isOperandConstantInt(op1)) {
</ins><span class="cx"> emitGetVirtualRegister(op2, regT1);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT1);
- int32_t op1imm = getConstantOperandImmediateInt(op1);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT1);
+ int32_t op1imm = getOperandConstantInt(op1);
</ins><span class="cx"> addJump(branch32(commute(condition), regT1, Imm32(op1imm)), target);
</span><span class="cx"> } else {
</span><span class="cx"> emitGetVirtualRegisters(op1, regT0, op2, regT1);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
- emitJumpSlowCaseIfNotImmediateInteger(regT1);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
+ emitJumpSlowCaseIfNotInt(regT1);
</ins><span class="cx">
</span><span class="cx"> addJump(branch32(condition, regT0, regT1), target);
</span><span class="cx"> }
</span><span class="lines">@@ -440,7 +436,7 @@
</span><span class="cx"> // - floating-point number to constant int immediate
</span><span class="cx"> // - constant int immediate to floating-point number
</span><span class="cx"> // - floating-point number to floating-point number.
</span><del>- if (isOperandConstantImmediateChar(op1) || isOperandConstantImmediateChar(op2)) {
</del><ins>+ if (isOperandConstantChar(op1) || isOperandConstantChar(op2)) {
</ins><span class="cx"> linkSlowCase(iter);
</span><span class="cx"> linkSlowCase(iter);
</span><span class="cx"> linkSlowCase(iter);
</span><span class="lines">@@ -453,11 +449,11 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (isOperandConstantImmediateInt(op2)) {
</del><ins>+ if (isOperandConstantInt(op2)) {
</ins><span class="cx"> linkSlowCase(iter);
</span><span class="cx">
</span><span class="cx"> if (supportsFloatingPoint()) {
</span><del>- Jump fail1 = emitJumpIfNotImmediateNumber(regT0);
</del><ins>+ Jump fail1 = emitJumpIfNotNumber(regT0);
</ins><span class="cx"> add64(tagTypeNumberRegister, regT0);
</span><span class="cx"> move64ToDouble(regT0, fpRegT0);
</span><span class="cx">
</span><span class="lines">@@ -476,11 +472,11 @@
</span><span class="cx"> emitGetVirtualRegister(op2, regT1);
</span><span class="cx"> callOperation(operation, regT0, regT1);
</span><span class="cx"> emitJumpSlowToHot(branchTest32(invert ? Zero : NonZero, returnValueGPR), target);
</span><del>- } else if (isOperandConstantImmediateInt(op1)) {
</del><ins>+ } else if (isOperandConstantInt(op1)) {
</ins><span class="cx"> linkSlowCase(iter);
</span><span class="cx">
</span><span class="cx"> if (supportsFloatingPoint()) {
</span><del>- Jump fail1 = emitJumpIfNotImmediateNumber(regT1);
</del><ins>+ Jump fail1 = emitJumpIfNotNumber(regT1);
</ins><span class="cx"> add64(tagTypeNumberRegister, regT1);
</span><span class="cx"> move64ToDouble(regT1, fpRegT1);
</span><span class="cx">
</span><span class="lines">@@ -503,9 +499,9 @@
</span><span class="cx"> linkSlowCase(iter);
</span><span class="cx">
</span><span class="cx"> if (supportsFloatingPoint()) {
</span><del>- Jump fail1 = emitJumpIfNotImmediateNumber(regT0);
- Jump fail2 = emitJumpIfNotImmediateNumber(regT1);
- Jump fail3 = emitJumpIfImmediateInteger(regT1);
</del><ins>+ Jump fail1 = emitJumpIfNotNumber(regT0);
+ Jump fail2 = emitJumpIfNotNumber(regT1);
+ Jump fail3 = emitJumpIfInt(regT1);
</ins><span class="cx"> add64(tagTypeNumberRegister, regT0);
</span><span class="cx"> add64(tagTypeNumberRegister, regT1);
</span><span class="cx"> move64ToDouble(regT0, fpRegT0);
</span><span class="lines">@@ -532,24 +528,24 @@
</span><span class="cx"> int op1 = currentInstruction[2].u.operand;
</span><span class="cx"> int op2 = currentInstruction[3].u.operand;
</span><span class="cx">
</span><del>- if (isOperandConstantImmediateInt(op1)) {
</del><ins>+ if (isOperandConstantInt(op1)) {
</ins><span class="cx"> emitGetVirtualRegister(op2, regT0);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
- int32_t imm = getConstantOperandImmediateInt(op1);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
+ int32_t imm = getOperandConstantInt(op1);
</ins><span class="cx"> and64(Imm32(imm), regT0);
</span><span class="cx"> if (imm >= 0)
</span><del>- emitFastArithIntToImmNoCheck(regT0, regT0);
- } else if (isOperandConstantImmediateInt(op2)) {
</del><ins>+ emitTagInt(regT0, regT0);
+ } else if (isOperandConstantInt(op2)) {
</ins><span class="cx"> emitGetVirtualRegister(op1, regT0);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
- int32_t imm = getConstantOperandImmediateInt(op2);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
+ int32_t imm = getOperandConstantInt(op2);
</ins><span class="cx"> and64(Imm32(imm), regT0);
</span><span class="cx"> if (imm >= 0)
</span><del>- emitFastArithIntToImmNoCheck(regT0, regT0);
</del><ins>+ emitTagInt(regT0, regT0);
</ins><span class="cx"> } else {
</span><span class="cx"> emitGetVirtualRegisters(op1, regT0, op2, regT1);
</span><span class="cx"> and64(regT1, regT0);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
</ins><span class="cx"> }
</span><span class="cx"> emitPutVirtualRegister(result);
</span><span class="cx"> }
</span><span class="lines">@@ -567,9 +563,9 @@
</span><span class="cx"> int srcDst = currentInstruction[1].u.operand;
</span><span class="cx">
</span><span class="cx"> emitGetVirtualRegister(srcDst, regT0);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
</ins><span class="cx"> addSlowCase(branchAdd32(Overflow, TrustedImm32(1), regT0));
</span><del>- emitFastArithIntToImmNoCheck(regT0, regT0);
</del><ins>+ emitTagInt(regT0, regT0);
</ins><span class="cx"> emitPutVirtualRegister(srcDst);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -586,9 +582,9 @@
</span><span class="cx"> int srcDst = currentInstruction[1].u.operand;
</span><span class="cx">
</span><span class="cx"> emitGetVirtualRegister(srcDst, regT0);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
</ins><span class="cx"> addSlowCase(branchSub32(Overflow, TrustedImm32(1), regT0));
</span><del>- emitFastArithIntToImmNoCheck(regT0, regT0);
</del><ins>+ emitTagInt(regT0, regT0);
</ins><span class="cx"> emitPutVirtualRegister(srcDst);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -618,8 +614,8 @@
</span><span class="cx"> ASSERT(regT4 != ecx);
</span><span class="cx">
</span><span class="cx"> emitGetVirtualRegisters(op1, regT4, op2, ecx);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT4);
- emitJumpSlowCaseIfNotImmediateInteger(ecx);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT4);
+ emitJumpSlowCaseIfNotInt(ecx);
</ins><span class="cx">
</span><span class="cx"> move(regT4, regT0);
</span><span class="cx"> addSlowCase(branchTest32(Zero, ecx));
</span><span class="lines">@@ -631,7 +627,7 @@
</span><span class="cx"> Jump numeratorPositive = branch32(GreaterThanOrEqual, regT4, TrustedImm32(0));
</span><span class="cx"> addSlowCase(branchTest32(Zero, edx));
</span><span class="cx"> numeratorPositive.link(this);
</span><del>- emitFastArithReTagImmediate(edx, regT0);
</del><ins>+ emitTagInt(edx, regT0);
</ins><span class="cx"> emitPutVirtualRegister(result);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -668,8 +664,8 @@
</span><span class="cx"> void JIT::compileBinaryArithOp(OpcodeID opcodeID, int, int op1, int op2, OperandTypes)
</span><span class="cx"> {
</span><span class="cx"> emitGetVirtualRegisters(op1, regT0, op2, regT1);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
- emitJumpSlowCaseIfNotImmediateInteger(regT1);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
+ emitJumpSlowCaseIfNotInt(regT1);
</ins><span class="cx"> RareCaseProfile* profile = m_codeBlock->addSpecialFastCaseProfile(m_bytecodeOffset);
</span><span class="cx"> if (opcodeID == op_add)
</span><span class="cx"> addSlowCase(branchAdd32(Overflow, regT1, regT0));
</span><span class="lines">@@ -701,7 +697,7 @@
</span><span class="cx"> addSlowCase(branchTest32(Zero, regT0));
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- emitFastArithIntToImmNoCheck(regT0, regT0);
</del><ins>+ emitTagInt(regT0, regT0);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void JIT::compileBinaryArithOpSlowCase(Instruction* currentInstruction, OpcodeID opcodeID, Vector<SlowCaseEntry>::iterator& iter, int result, int op1, int op2, OperandTypes types, bool op1HasImmediateIntFastCase, bool op2HasImmediateIntFastCase)
</span><span class="lines">@@ -733,7 +729,7 @@
</span><span class="cx"> if (op1HasImmediateIntFastCase) {
</span><span class="cx"> notImm2.link(this);
</span><span class="cx"> if (!types.second().definitelyIsNumber())
</span><del>- emitJumpIfNotImmediateNumber(regT0).linkTo(stubFunctionCall, this);
</del><ins>+ emitJumpIfNotNumber(regT0).linkTo(stubFunctionCall, this);
</ins><span class="cx"> emitGetVirtualRegister(op1, regT1);
</span><span class="cx"> convertInt32ToDouble(regT1, fpRegT1);
</span><span class="cx"> add64(tagTypeNumberRegister, regT0);
</span><span class="lines">@@ -741,7 +737,7 @@
</span><span class="cx"> } else if (op2HasImmediateIntFastCase) {
</span><span class="cx"> notImm1.link(this);
</span><span class="cx"> if (!types.first().definitelyIsNumber())
</span><del>- emitJumpIfNotImmediateNumber(regT0).linkTo(stubFunctionCall, this);
</del><ins>+ emitJumpIfNotNumber(regT0).linkTo(stubFunctionCall, this);
</ins><span class="cx"> emitGetVirtualRegister(op2, regT1);
</span><span class="cx"> convertInt32ToDouble(regT1, fpRegT1);
</span><span class="cx"> add64(tagTypeNumberRegister, regT0);
</span><span class="lines">@@ -750,19 +746,19 @@
</span><span class="cx"> // if we get here, eax is not an int32, edx not yet checked.
</span><span class="cx"> notImm1.link(this);
</span><span class="cx"> if (!types.first().definitelyIsNumber())
</span><del>- emitJumpIfNotImmediateNumber(regT0).linkTo(stubFunctionCall, this);
</del><ins>+ emitJumpIfNotNumber(regT0).linkTo(stubFunctionCall, this);
</ins><span class="cx"> if (!types.second().definitelyIsNumber())
</span><del>- emitJumpIfNotImmediateNumber(regT1).linkTo(stubFunctionCall, this);
</del><ins>+ emitJumpIfNotNumber(regT1).linkTo(stubFunctionCall, this);
</ins><span class="cx"> add64(tagTypeNumberRegister, regT0);
</span><span class="cx"> move64ToDouble(regT0, fpRegT1);
</span><del>- Jump op2isDouble = emitJumpIfNotImmediateInteger(regT1);
</del><ins>+ Jump op2isDouble = emitJumpIfNotInt(regT1);
</ins><span class="cx"> convertInt32ToDouble(regT1, fpRegT2);
</span><span class="cx"> Jump op2wasInteger = jump();
</span><span class="cx">
</span><span class="cx"> // if we get here, eax IS an int32, edx is not.
</span><span class="cx"> notImm2.link(this);
</span><span class="cx"> if (!types.second().definitelyIsNumber())
</span><del>- emitJumpIfNotImmediateNumber(regT1).linkTo(stubFunctionCall, this);
</del><ins>+ emitJumpIfNotNumber(regT1).linkTo(stubFunctionCall, this);
</ins><span class="cx"> convertInt32ToDouble(regT0, fpRegT1);
</span><span class="cx"> op2isDouble.link(this);
</span><span class="cx"> add64(tagTypeNumberRegister, regT1);
</span><span class="lines">@@ -800,16 +796,16 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (isOperandConstantImmediateInt(op1)) {
</del><ins>+ if (isOperandConstantInt(op1)) {
</ins><span class="cx"> emitGetVirtualRegister(op2, regT0);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
- addSlowCase(branchAdd32(Overflow, regT0, Imm32(getConstantOperandImmediateInt(op1)), regT1));
- emitFastArithIntToImmNoCheck(regT1, regT0);
- } else if (isOperandConstantImmediateInt(op2)) {
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
+ addSlowCase(branchAdd32(Overflow, regT0, Imm32(getOperandConstantInt(op1)), regT1));
+ emitTagInt(regT1, regT0);
+ } else if (isOperandConstantInt(op2)) {
</ins><span class="cx"> emitGetVirtualRegister(op1, regT0);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
- addSlowCase(branchAdd32(Overflow, regT0, Imm32(getConstantOperandImmediateInt(op2)), regT1));
- emitFastArithIntToImmNoCheck(regT1, regT0);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
+ addSlowCase(branchAdd32(Overflow, regT0, Imm32(getOperandConstantInt(op2)), regT1));
+ emitTagInt(regT1, regT0);
</ins><span class="cx"> } else
</span><span class="cx"> compileBinaryArithOp(op_add, result, op1, op2, types);
</span><span class="cx">
</span><span class="lines">@@ -825,8 +821,8 @@
</span><span class="cx">
</span><span class="cx"> RELEASE_ASSERT(types.first().mightBeNumber() && types.second().mightBeNumber());
</span><span class="cx">
</span><del>- bool op1HasImmediateIntFastCase = isOperandConstantImmediateInt(op1);
- bool op2HasImmediateIntFastCase = !op1HasImmediateIntFastCase && isOperandConstantImmediateInt(op2);
</del><ins>+ bool op1HasImmediateIntFastCase = isOperandConstantInt(op1);
+ bool op2HasImmediateIntFastCase = !op1HasImmediateIntFastCase && isOperandConstantInt(op2);
</ins><span class="cx"> compileBinaryArithOpSlowCase(currentInstruction, op_add, iter, result, op1, op2, types, op1HasImmediateIntFastCase, op2HasImmediateIntFastCase);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -839,20 +835,20 @@
</span><span class="cx">
</span><span class="cx"> // For now, only plant a fast int case if the constant operand is greater than zero.
</span><span class="cx"> int32_t value;
</span><del>- if (isOperandConstantImmediateInt(op1) && ((value = getConstantOperandImmediateInt(op1)) > 0)) {
</del><ins>+ if (isOperandConstantInt(op1) && ((value = getOperandConstantInt(op1)) > 0)) {
</ins><span class="cx"> // Add a special fast case profile because the DFG JIT will expect one.
</span><span class="cx"> m_codeBlock->addSpecialFastCaseProfile(m_bytecodeOffset);
</span><span class="cx"> emitGetVirtualRegister(op2, regT0);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
</ins><span class="cx"> addSlowCase(branchMul32(Overflow, Imm32(value), regT0, regT1));
</span><del>- emitFastArithReTagImmediate(regT1, regT0);
- } else if (isOperandConstantImmediateInt(op2) && ((value = getConstantOperandImmediateInt(op2)) > 0)) {
</del><ins>+ emitTagInt(regT1, regT0);
+ } else if (isOperandConstantInt(op2) && ((value = getOperandConstantInt(op2)) > 0)) {
</ins><span class="cx"> // Add a special fast case profile because the DFG JIT will expect one.
</span><span class="cx"> m_codeBlock->addSpecialFastCaseProfile(m_bytecodeOffset);
</span><span class="cx"> emitGetVirtualRegister(op1, regT0);
</span><del>- emitJumpSlowCaseIfNotImmediateInteger(regT0);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0);
</ins><span class="cx"> addSlowCase(branchMul32(Overflow, Imm32(value), regT0, regT1));
</span><del>- emitFastArithReTagImmediate(regT1, regT0);
</del><ins>+ emitTagInt(regT1, regT0);
</ins><span class="cx"> } else
</span><span class="cx"> compileBinaryArithOp(op_mul, result, op1, op2, types);
</span><span class="cx">
</span><span class="lines">@@ -866,8 +862,8 @@
</span><span class="cx"> int op2 = currentInstruction[3].u.operand;
</span><span class="cx"> OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
</span><span class="cx">
</span><del>- bool op1HasImmediateIntFastCase = isOperandConstantImmediateInt(op1) && getConstantOperandImmediateInt(op1) > 0;
- bool op2HasImmediateIntFastCase = !op1HasImmediateIntFastCase && isOperandConstantImmediateInt(op2) && getConstantOperandImmediateInt(op2) > 0;
</del><ins>+ bool op1HasImmediateIntFastCase = isOperandConstantInt(op1) && getOperandConstantInt(op1) > 0;
+ bool op2HasImmediateIntFastCase = !op1HasImmediateIntFastCase && isOperandConstantInt(op2) && getOperandConstantInt(op2) > 0;
</ins><span class="cx"> compileBinaryArithOpSlowCase(currentInstruction, op_mul, iter, result, op1, op2, types, op1HasImmediateIntFastCase, op2HasImmediateIntFastCase);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -878,17 +874,17 @@
</span><span class="cx"> int op2 = currentInstruction[3].u.operand;
</span><span class="cx"> OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
</span><span class="cx">
</span><del>- if (isOperandConstantImmediateDouble(op1)) {
</del><ins>+ if (isOperandConstantDouble(op1)) {
</ins><span class="cx"> emitGetVirtualRegister(op1, regT0);
</span><span class="cx"> add64(tagTypeNumberRegister, regT0);
</span><span class="cx"> move64ToDouble(regT0, fpRegT0);
</span><del>- } else if (isOperandConstantImmediateInt(op1)) {
</del><ins>+ } else if (isOperandConstantInt(op1)) {
</ins><span class="cx"> emitLoadInt32ToDouble(op1, fpRegT0);
</span><span class="cx"> } else {
</span><span class="cx"> emitGetVirtualRegister(op1, regT0);
</span><span class="cx"> if (!types.first().definitelyIsNumber())
</span><del>- emitJumpSlowCaseIfNotImmediateNumber(regT0);
- Jump notInt = emitJumpIfNotImmediateInteger(regT0);
</del><ins>+ emitJumpSlowCaseIfNotNumber(regT0);
+ Jump notInt = emitJumpIfNotInt(regT0);
</ins><span class="cx"> convertInt32ToDouble(regT0, fpRegT0);
</span><span class="cx"> Jump skipDoubleLoad = jump();
</span><span class="cx"> notInt.link(this);
</span><span class="lines">@@ -897,17 +893,17 @@
</span><span class="cx"> skipDoubleLoad.link(this);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (isOperandConstantImmediateDouble(op2)) {
</del><ins>+ if (isOperandConstantDouble(op2)) {
</ins><span class="cx"> emitGetVirtualRegister(op2, regT1);
</span><span class="cx"> add64(tagTypeNumberRegister, regT1);
</span><span class="cx"> move64ToDouble(regT1, fpRegT1);
</span><del>- } else if (isOperandConstantImmediateInt(op2)) {
</del><ins>+ } else if (isOperandConstantInt(op2)) {
</ins><span class="cx"> emitLoadInt32ToDouble(op2, fpRegT1);
</span><span class="cx"> } else {
</span><span class="cx"> emitGetVirtualRegister(op2, regT1);
</span><span class="cx"> if (!types.second().definitelyIsNumber())
</span><del>- emitJumpSlowCaseIfNotImmediateNumber(regT1);
- Jump notInt = emitJumpIfNotImmediateInteger(regT1);
</del><ins>+ emitJumpSlowCaseIfNotNumber(regT1);
+ Jump notInt = emitJumpIfNotInt(regT1);
</ins><span class="cx"> convertInt32ToDouble(regT1, fpRegT1);
</span><span class="cx"> Jump skipDoubleLoad = jump();
</span><span class="cx"> notInt.link(this);
</span><span class="lines">@@ -931,7 +927,7 @@
</span><span class="cx"> JumpList notInteger;
</span><span class="cx"> branchConvertDoubleToInt32(fpRegT0, regT0, notInteger, fpRegT1);
</span><span class="cx"> // If we've got an integer, we might as well make that the result of the division.
</span><del>- emitFastArithReTagImmediate(regT0, regT0);
</del><ins>+ emitTagInt(regT0, regT0);
</ins><span class="cx"> Jump isInteger = jump();
</span><span class="cx"> notInteger.link(this);
</span><span class="cx"> moveDoubleTo64(fpRegT0, regT0);
</span><span class="lines">@@ -957,11 +953,11 @@
</span><span class="cx"> abortWithReason(JITDivOperandsAreNotNumbers);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (!isOperandConstantImmediateDouble(op1) && !isOperandConstantImmediateInt(op1)) {
</del><ins>+ if (!isOperandConstantDouble(op1) && !isOperandConstantInt(op1)) {
</ins><span class="cx"> if (!types.first().definitelyIsNumber())
</span><span class="cx"> linkSlowCase(iter);
</span><span class="cx"> }
</span><del>- if (!isOperandConstantImmediateDouble(op2) && !isOperandConstantImmediateInt(op2)) {
</del><ins>+ if (!isOperandConstantDouble(op2) && !isOperandConstantInt(op2)) {
</ins><span class="cx"> if (!types.second().definitelyIsNumber())
</span><span class="cx"> linkSlowCase(iter);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITArithmetic32_64cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITArithmetic32_64.cpp (190229 => 190230)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITArithmetic32_64.cpp 2015-09-24 23:33:34 UTC (rev 190229)
+++ trunk/Source/JavaScriptCore/jit/JITArithmetic32_64.cpp 2015-09-25 00:17:16 UTC (rev 190230)
</span><span class="lines">@@ -83,7 +83,7 @@
</span><span class="cx"> JumpList notInt32Op2;
</span><span class="cx">
</span><span class="cx"> // Character less.
</span><del>- if (isOperandConstantImmediateChar(op1)) {
</del><ins>+ if (isOperandConstantChar(op1)) {
</ins><span class="cx"> emitLoad(op2, regT1, regT0);
</span><span class="cx"> addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag)));
</span><span class="cx"> JumpList failures;
</span><span class="lines">@@ -92,7 +92,7 @@
</span><span class="cx"> addJump(branch32(commute(condition), regT0, Imm32(asString(getConstantOperand(op1))->tryGetValue()[0])), target);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (isOperandConstantImmediateChar(op2)) {
</del><ins>+ if (isOperandConstantChar(op2)) {
</ins><span class="cx"> emitLoad(op1, regT1, regT0);
</span><span class="cx"> addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag)));
</span><span class="cx"> JumpList failures;
</span><span class="lines">@@ -101,11 +101,11 @@
</span><span class="cx"> addJump(branch32(condition, regT0, Imm32(asString(getConstantOperand(op2))->tryGetValue()[0])), target);
</span><span class="cx"> return;
</span><span class="cx"> }
</span><del>- if (isOperandConstantImmediateInt(op1)) {
</del><ins>+ if (isOperandConstantInt(op1)) {
</ins><span class="cx"> emitLoad(op2, regT3, regT2);
</span><span class="cx"> notInt32Op2.append(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</span><span class="cx"> addJump(branch32(commute(condition), regT2, Imm32(getConstantOperand(op1).asInt32())), target);
</span><del>- } else if (isOperandConstantImmediateInt(op2)) {
</del><ins>+ } else if (isOperandConstantInt(op2)) {
</ins><span class="cx"> emitLoad(op1, regT1, regT0);
</span><span class="cx"> notInt32Op1.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</span><span class="cx"> addJump(branch32(condition, regT0, Imm32(getConstantOperand(op2).asInt32())), target);
</span><span class="lines">@@ -124,28 +124,28 @@
</span><span class="cx"> Jump end = jump();
</span><span class="cx">
</span><span class="cx"> // Double less.
</span><del>- emitBinaryDoubleOp(opcode, target, op1, op2, OperandTypes(), notInt32Op1, notInt32Op2, !isOperandConstantImmediateInt(op1), isOperandConstantImmediateInt(op1) || !isOperandConstantImmediateInt(op2));
</del><ins>+ emitBinaryDoubleOp(opcode, target, op1, op2, OperandTypes(), notInt32Op1, notInt32Op2, !isOperandConstantInt(op1), isOperandConstantInt(op1) || !isOperandConstantInt(op2));
</ins><span class="cx"> end.link(this);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void JIT::emit_compareAndJumpSlow(int op1, int op2, unsigned target, DoubleCondition, size_t (JIT_OPERATION *operation)(ExecState*, EncodedJSValue, EncodedJSValue), bool invert, Vector<SlowCaseEntry>::iterator& iter)
</span><span class="cx"> {
</span><del>- if (isOperandConstantImmediateChar(op1) || isOperandConstantImmediateChar(op2)) {
</del><ins>+ if (isOperandConstantChar(op1) || isOperandConstantChar(op2)) {
</ins><span class="cx"> linkSlowCase(iter);
</span><span class="cx"> linkSlowCase(iter);
</span><span class="cx"> linkSlowCase(iter);
</span><span class="cx"> linkSlowCase(iter);
</span><span class="cx"> } else {
</span><span class="cx"> if (!supportsFloatingPoint()) {
</span><del>- if (!isOperandConstantImmediateInt(op1) && !isOperandConstantImmediateInt(op2))
</del><ins>+ if (!isOperandConstantInt(op1) && !isOperandConstantInt(op2))
</ins><span class="cx"> linkSlowCase(iter); // int32 check
</span><span class="cx"> linkSlowCase(iter); // int32 check
</span><span class="cx"> } else {
</span><del>- if (!isOperandConstantImmediateInt(op1)) {
</del><ins>+ if (!isOperandConstantInt(op1)) {
</ins><span class="cx"> linkSlowCase(iter); // double check
</span><span class="cx"> linkSlowCase(iter); // int32 check
</span><span class="cx"> }
</span><del>- if (isOperandConstantImmediateInt(op1) || !isOperandConstantImmediateInt(op2))
</del><ins>+ if (isOperandConstantInt(op1) || !isOperandConstantInt(op2))
</ins><span class="cx"> linkSlowCase(iter); // double check
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="lines">@@ -163,7 +163,7 @@
</span><span class="cx"> int op1 = currentInstruction[2].u.operand;
</span><span class="cx"> int op2 = currentInstruction[3].u.operand;
</span><span class="cx">
</span><del>- if (isOperandConstantImmediateInt(op2)) {
</del><ins>+ if (isOperandConstantInt(op2)) {
</ins><span class="cx"> emitLoad(op1, regT1, regT0);
</span><span class="cx"> addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</span><span class="cx"> lshift32(Imm32(getConstantOperand(op2).asInt32()), regT0);
</span><span class="lines">@@ -172,7 +172,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><del>- if (!isOperandConstantImmediateInt(op1))
</del><ins>+ if (!isOperandConstantInt(op1))
</ins><span class="cx"> addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</span><span class="cx"> addSlowCase(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</span><span class="cx"> lshift32(regT2, regT0);
</span><span class="lines">@@ -184,7 +184,7 @@
</span><span class="cx"> int op1 = currentInstruction[2].u.operand;
</span><span class="cx"> int op2 = currentInstruction[3].u.operand;
</span><span class="cx">
</span><del>- if (!isOperandConstantImmediateInt(op1) && !isOperandConstantImmediateInt(op2))
</del><ins>+ if (!isOperandConstantInt(op1) && !isOperandConstantInt(op2))
</ins><span class="cx"> linkSlowCase(iter); // int32 check
</span><span class="cx"> linkSlowCase(iter); // int32 check
</span><span class="cx">
</span><span class="lines">@@ -202,7 +202,7 @@
</span><span class="cx">
</span><span class="cx"> // Slow case of rshift makes assumptions about what registers hold the
</span><span class="cx"> // shift arguments, so any changes must be updated there as well.
</span><del>- if (isOperandConstantImmediateInt(op2)) {
</del><ins>+ if (isOperandConstantInt(op2)) {
</ins><span class="cx"> emitLoad(op1, regT1, regT0);
</span><span class="cx"> addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</span><span class="cx"> int shift = getConstantOperand(op2).asInt32() & 0x1f;
</span><span class="lines">@@ -215,7 +215,7 @@
</span><span class="cx"> emitStoreInt32(dst, regT0, dst == op1);
</span><span class="cx"> } else {
</span><span class="cx"> emitLoad2(op1, regT1, regT0, op2, regT3, regT2);
</span><del>- if (!isOperandConstantImmediateInt(op1))
</del><ins>+ if (!isOperandConstantInt(op1))
</ins><span class="cx"> addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</span><span class="cx"> addSlowCase(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
</span><span class="cx"> if (isUnsigned)
</span><span class="lines">@@ -231,7 +231,7 @@
</span><span class="cx"> int dst = currentInstruction[1].u.operand;
</span><span class="cx"> int op1 = currentInstruction[2].u.operand;
</span><span class="cx"> int op2 = currentInstruction[3].u.operand;
</span><del>- if (isOperandConstantImmediateInt(op2)) {
</del><ins>+ if (isOperandConstantInt(op2)) {
</ins><span class="cx"> int shift = getConstantOperand(op2).asInt32() & 0x1f;
</span><span class="cx"> // op1 = regT1:regT0
</span><span class="cx"> linkSlowCase(iter); // int32 check
</span><span class="lines">@@ -254,7 +254,7 @@
</span><span class="cx"> } else {
</span><span class="cx"> // op1 = regT1:regT0
</span><span class="cx"> // op2 = regT3:regT2
</span><del>- if (!isOperandConstantImmediateInt(op1)) {
</del><ins>+ if (!isOperandConstantInt(op1)) {
</ins><span class="cx"> linkSlowCase(iter); // int32 check -- op1 is not an int
</span><span class="cx"> if (supportsFloatingPointTruncate()) {
</span><span class="cx"> JumpList failures;
</span><span class="lines">@@ -335,7 +335,7 @@
</span><span class="cx">
</span><span class="cx"> int op;
</span><span class="cx"> int32_t constant;
</span><del>- if (getOperandConstantImmediateInt(op1, op2, op, constant)) {
</del><ins>+ if (getOperandConstantInt(op1, op2, op, constant)) {
</ins><span class="cx"> emitLoad(op, regT1, regT0);
</span><span class="cx"> addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</span><span class="cx"> and32(Imm32(constant), regT0);
</span><span class="lines">@@ -355,7 +355,7 @@
</span><span class="cx"> int op1 = currentInstruction[2].u.operand;
</span><span class="cx"> int op2 = currentInstruction[3].u.operand;
</span><span class="cx">
</span><del>- if (!isOperandConstantImmediateInt(op1) && !isOperandConstantImmediateInt(op2))
</del><ins>+ if (!isOperandConstantInt(op1) && !isOperandConstantInt(op2))
</ins><span class="cx"> linkSlowCase(iter); // int32 check
</span><span class="cx"> linkSlowCase(iter); // int32 check
</span><span class="cx">
</span><span class="lines">@@ -373,7 +373,7 @@
</span><span class="cx">
</span><span class="cx"> int op;
</span><span class="cx"> int32_t constant;
</span><del>- if (getOperandConstantImmediateInt(op1, op2, op, constant)) {
</del><ins>+ if (getOperandConstantInt(op1, op2, op, constant)) {
</ins><span class="cx"> emitLoad(op, regT1, regT0);
</span><span class="cx"> addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</span><span class="cx"> or32(Imm32(constant), regT0);
</span><span class="lines">@@ -393,7 +393,7 @@
</span><span class="cx"> int op1 = currentInstruction[2].u.operand;
</span><span class="cx"> int op2 = currentInstruction[3].u.operand;
</span><span class="cx">
</span><del>- if (!isOperandConstantImmediateInt(op1) && !isOperandConstantImmediateInt(op2))
</del><ins>+ if (!isOperandConstantInt(op1) && !isOperandConstantInt(op2))
</ins><span class="cx"> linkSlowCase(iter); // int32 check
</span><span class="cx"> linkSlowCase(iter); // int32 check
</span><span class="cx">
</span><span class="lines">@@ -411,7 +411,7 @@
</span><span class="cx">
</span><span class="cx"> int op;
</span><span class="cx"> int32_t constant;
</span><del>- if (getOperandConstantImmediateInt(op1, op2, op, constant)) {
</del><ins>+ if (getOperandConstantInt(op1, op2, op, constant)) {
</ins><span class="cx"> emitLoad(op, regT1, regT0);
</span><span class="cx"> addSlowCase(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
</span><span class="cx"> xor32(Imm32(constant), regT0);
</span><span class="lines">@@ -431,7 +431,7 @@
</span><span class="cx"> int op1 = currentInstruction[2].u.operand;
</span><span class="cx"> int op2 = currentInstruction[3].u.operand;
</span><span class="cx">
</span><del>- if (!isOperandConstantImmediateInt(op1) && !isOperandConstantImmediateInt(op2))
</del><ins>+ if (!isOperandConstantInt(op1) && !isOperandConstantInt(op2))
</ins><span class="cx"> linkSlowCase(iter); // int32 check
</span><span class="cx"> linkSlowCase(iter); // int32 check
</span><span class="cx">
</span><span class="lines">@@ -499,7 +499,7 @@
</span><span class="cx">
</span><span class="cx"> int op;
</span><span class="cx"> int32_t constant;
</span><del>- if (getOperandConstantImmediateInt(op1, op2, op, constant)) {
</del><ins>+ if (getOperandConstantInt(op1, op2, op, constant)) {
</ins><span class="cx"> emitAdd32Constant(dst, op, constant, op == op1 ? types.first() : types.second());
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -561,7 +561,7 @@
</span><span class="cx">
</span><span class="cx"> int op;
</span><span class="cx"> int32_t constant;
</span><del>- if (getOperandConstantImmediateInt(op1, op2, op, constant)) {
</del><ins>+ if (getOperandConstantInt(op1, op2, op, constant)) {
</ins><span class="cx"> linkSlowCase(iter); // overflow check
</span><span class="cx">
</span><span class="cx"> if (!supportsFloatingPoint())
</span><span class="lines">@@ -604,7 +604,7 @@
</span><span class="cx"> JumpList notInt32Op1;
</span><span class="cx"> JumpList notInt32Op2;
</span><span class="cx">
</span><del>- if (isOperandConstantImmediateInt(op2)) {
</del><ins>+ if (isOperandConstantInt(op2)) {
</ins><span class="cx"> emitSub32Constant(dst, op1, getConstantOperand(op2).asInt32(), types.first());
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -661,7 +661,7 @@
</span><span class="cx"> int op2 = currentInstruction[3].u.operand;
</span><span class="cx"> OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
</span><span class="cx">
</span><del>- if (isOperandConstantImmediateInt(op2)) {
</del><ins>+ if (isOperandConstantInt(op2)) {
</ins><span class="cx"> linkSlowCase(iter); // overflow check
</span><span class="cx">
</span><span class="cx"> if (!supportsFloatingPoint() || !types.first().definitelyIsNumber())
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITInlinesh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITInlines.h (190229 => 190230)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITInlines.h 2015-09-24 23:33:34 UTC (rev 190229)
+++ trunk/Source/JavaScriptCore/jit/JITInlines.h 2015-09-25 00:17:16 UTC (rev 190230)
</span><span class="lines">@@ -77,7 +77,7 @@
</span><span class="cx"> return emitArrayStorageLoad(instruction, badType);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-ALWAYS_INLINE bool JIT::isOperandConstantImmediateDouble(int src)
</del><ins>+ALWAYS_INLINE bool JIT::isOperandConstantDouble(int src)
</ins><span class="cx"> {
</span><span class="cx"> return m_codeBlock->isConstantRegisterIndex(src) && getConstantOperand(src).isDouble();
</span><span class="cx"> }
</span><span class="lines">@@ -871,7 +871,7 @@
</span><span class="cx"> #endif
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>-ALWAYS_INLINE bool JIT::isOperandConstantImmediateChar(int src)
</del><ins>+ALWAYS_INLINE bool JIT::isOperandConstantChar(int src)
</ins><span class="cx"> {
</span><span class="cx"> return m_codeBlock->isConstantRegisterIndex(src) && getConstantOperand(src).isString() && asString(getConstantOperand(src).asCell())->length() == 1;
</span><span class="cx"> }
</span><span class="lines">@@ -1114,20 +1114,20 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>-ALWAYS_INLINE bool JIT::isOperandConstantImmediateInt(int src)
</del><ins>+ALWAYS_INLINE bool JIT::isOperandConstantInt(int src)
</ins><span class="cx"> {
</span><span class="cx"> return m_codeBlock->isConstantRegisterIndex(src) && getConstantOperand(src).isInt32();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-ALWAYS_INLINE bool JIT::getOperandConstantImmediateInt(int op1, int op2, int& op, int32_t& constant)
</del><ins>+ALWAYS_INLINE bool JIT::getOperandConstantInt(int op1, int op2, int& op, int32_t& constant)
</ins><span class="cx"> {
</span><del>- if (isOperandConstantImmediateInt(op1)) {
</del><ins>+ if (isOperandConstantInt(op1)) {
</ins><span class="cx"> constant = getConstantOperand(op1).asInt32();
</span><span class="cx"> op = op2;
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (isOperandConstantImmediateInt(op2)) {
</del><ins>+ if (isOperandConstantInt(op2)) {
</ins><span class="cx"> constant = getConstantOperand(op2).asInt32();
</span><span class="cx"> op = op1;
</span><span class="cx"> return true;
</span><span class="lines">@@ -1172,12 +1172,12 @@
</span><span class="cx"> emitGetVirtualRegisters(src1.offset(), dst1, src2.offset(), dst2);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-ALWAYS_INLINE int32_t JIT::getConstantOperandImmediateInt(int src)
</del><ins>+ALWAYS_INLINE int32_t JIT::getOperandConstantInt(int src)
</ins><span class="cx"> {
</span><span class="cx"> return getConstantOperand(src).asInt32();
</span><span class="cx"> }
</span><span class="cx">
</span><del>-ALWAYS_INLINE bool JIT::isOperandConstantImmediateInt(int src)
</del><ins>+ALWAYS_INLINE bool JIT::isOperandConstantInt(int src)
</ins><span class="cx"> {
</span><span class="cx"> return m_codeBlock->isConstantRegisterIndex(src) && getConstantOperand(src).isInt32();
</span><span class="cx"> }
</span><span class="lines">@@ -1237,56 +1237,51 @@
</span><span class="cx"> inline void JIT::emitLoadInt32ToDouble(int index, FPRegisterID value)
</span><span class="cx"> {
</span><span class="cx"> if (m_codeBlock->isConstantRegisterIndex(index)) {
</span><del>- ASSERT(isOperandConstantImmediateInt(index));
</del><ins>+ ASSERT(isOperandConstantInt(index));
</ins><span class="cx"> convertInt32ToDouble(Imm32(getConstantOperand(index).asInt32()), value);
</span><span class="cx"> } else
</span><span class="cx"> convertInt32ToDouble(addressFor(index), value);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-ALWAYS_INLINE JIT::Jump JIT::emitJumpIfImmediateInteger(RegisterID reg)
</del><ins>+ALWAYS_INLINE JIT::Jump JIT::emitJumpIfInt(RegisterID reg)
</ins><span class="cx"> {
</span><span class="cx"> return branch64(AboveOrEqual, reg, tagTypeNumberRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-ALWAYS_INLINE JIT::Jump JIT::emitJumpIfNotImmediateInteger(RegisterID reg)
</del><ins>+ALWAYS_INLINE JIT::Jump JIT::emitJumpIfNotInt(RegisterID reg)
</ins><span class="cx"> {
</span><span class="cx"> return branch64(Below, reg, tagTypeNumberRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-ALWAYS_INLINE JIT::PatchableJump JIT::emitPatchableJumpIfNotImmediateInteger(RegisterID reg)
</del><ins>+ALWAYS_INLINE JIT::PatchableJump JIT::emitPatchableJumpIfNotInt(RegisterID reg)
</ins><span class="cx"> {
</span><span class="cx"> return patchableBranch64(Below, reg, tagTypeNumberRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-ALWAYS_INLINE JIT::Jump JIT::emitJumpIfNotImmediateIntegers(RegisterID reg1, RegisterID reg2, RegisterID scratch)
</del><ins>+ALWAYS_INLINE JIT::Jump JIT::emitJumpIfNotInt(RegisterID reg1, RegisterID reg2, RegisterID scratch)
</ins><span class="cx"> {
</span><span class="cx"> move(reg1, scratch);
</span><span class="cx"> and64(reg2, scratch);
</span><del>- return emitJumpIfNotImmediateInteger(scratch);
</del><ins>+ return emitJumpIfNotInt(scratch);
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotImmediateInteger(RegisterID reg)
</del><ins>+ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotInt(RegisterID reg)
</ins><span class="cx"> {
</span><del>- addSlowCase(emitJumpIfNotImmediateInteger(reg));
</del><ins>+ addSlowCase(emitJumpIfNotInt(reg));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotImmediateIntegers(RegisterID reg1, RegisterID reg2, RegisterID scratch)
</del><ins>+ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotInt(RegisterID reg1, RegisterID reg2, RegisterID scratch)
</ins><span class="cx"> {
</span><del>- addSlowCase(emitJumpIfNotImmediateIntegers(reg1, reg2, scratch));
</del><ins>+ addSlowCase(emitJumpIfNotInt(reg1, reg2, scratch));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotImmediateNumber(RegisterID reg)
</del><ins>+ALWAYS_INLINE void JIT::emitJumpSlowCaseIfNotNumber(RegisterID reg)
</ins><span class="cx"> {
</span><del>- addSlowCase(emitJumpIfNotImmediateNumber(reg));
</del><ins>+ addSlowCase(emitJumpIfNotNumber(reg));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-ALWAYS_INLINE void JIT::emitFastArithReTagImmediate(RegisterID src, RegisterID dest)
</del><ins>+ALWAYS_INLINE void JIT::emitTagBool(RegisterID reg)
</ins><span class="cx"> {
</span><del>- emitFastArithIntToImmNoCheck(src, dest);
-}
-
-ALWAYS_INLINE void JIT::emitTagAsBoolImmediate(RegisterID reg)
-{
</del><span class="cx"> or32(TrustedImm32(static_cast<int32_t>(ValueFalse)), reg);
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITOpcodescpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp (190229 => 190230)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp 2015-09-24 23:33:34 UTC (rev 190229)
+++ trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp 2015-09-25 00:17:16 UTC (rev 190230)
</span><span class="lines">@@ -181,7 +181,7 @@
</span><span class="cx">
</span><span class="cx"> notMasqueradesAsUndefined.link(this);
</span><span class="cx"> done.link(this);
</span><del>- emitTagAsBoolImmediate(regT0);
</del><ins>+ emitTagBool(regT0);
</ins><span class="cx"> emitPutVirtualRegister(dst);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -193,7 +193,7 @@
</span><span class="cx"> emitGetVirtualRegister(value, regT0);
</span><span class="cx"> xor64(TrustedImm32(static_cast<int32_t>(ValueFalse)), regT0);
</span><span class="cx"> test64(Zero, regT0, TrustedImm32(static_cast<int32_t>(~1)), regT0);
</span><del>- emitTagAsBoolImmediate(regT0);
</del><ins>+ emitTagBool(regT0);
</ins><span class="cx"> emitPutVirtualRegister(dst);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -204,7 +204,7 @@
</span><span class="cx">
</span><span class="cx"> emitGetVirtualRegister(value, regT0);
</span><span class="cx"> test64(NonZero, regT0, tagTypeNumberRegister, regT0);
</span><del>- emitTagAsBoolImmediate(regT0);
</del><ins>+ emitTagBool(regT0);
</ins><span class="cx"> emitPutVirtualRegister(dst);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -217,7 +217,7 @@
</span><span class="cx"> Jump isNotCell = emitJumpIfNotJSCell(regT0);
</span><span class="cx">
</span><span class="cx"> compare8(Equal, Address(regT0, JSCell::typeInfoTypeOffset()), TrustedImm32(StringType), regT0);
</span><del>- emitTagAsBoolImmediate(regT0);
</del><ins>+ emitTagBool(regT0);
</ins><span class="cx"> Jump done = jump();
</span><span class="cx">
</span><span class="cx"> isNotCell.link(this);
</span><span class="lines">@@ -236,7 +236,7 @@
</span><span class="cx"> Jump isNotCell = emitJumpIfNotJSCell(regT0);
</span><span class="cx">
</span><span class="cx"> compare8(AboveOrEqual, Address(regT0, JSCell::typeInfoTypeOffset()), TrustedImm32(ObjectType), regT0);
</span><del>- emitTagAsBoolImmediate(regT0);
</del><ins>+ emitTagBool(regT0);
</ins><span class="cx"> Jump done = jump();
</span><span class="cx">
</span><span class="cx"> isNotCell.link(this);
</span><span class="lines">@@ -303,7 +303,7 @@
</span><span class="cx"> emitGetVirtualRegister(currentInstruction[1].u.operand, regT0);
</span><span class="cx">
</span><span class="cx"> addJump(branch64(Equal, regT0, TrustedImm64(JSValue::encode(jsNumber(0)))), target);
</span><del>- Jump isNonZero = emitJumpIfImmediateInteger(regT0);
</del><ins>+ Jump isNonZero = emitJumpIfInt(regT0);
</ins><span class="cx">
</span><span class="cx"> addJump(branch64(Equal, regT0, TrustedImm64(JSValue::encode(jsBoolean(false)))), target);
</span><span class="cx"> addSlowCase(branch64(NotEqual, regT0, TrustedImm64(JSValue::encode(jsBoolean(true)))));
</span><span class="lines">@@ -370,9 +370,9 @@
</span><span class="cx"> void JIT::emit_op_eq(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> emitGetVirtualRegisters(currentInstruction[2].u.operand, regT0, currentInstruction[3].u.operand, regT1);
</span><del>- emitJumpSlowCaseIfNotImmediateIntegers(regT0, regT1, regT2);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0, regT1, regT2);
</ins><span class="cx"> compare32(Equal, regT1, regT0, regT0);
</span><del>- emitTagAsBoolImmediate(regT0);
</del><ins>+ emitTagBool(regT0);
</ins><span class="cx"> emitPutVirtualRegister(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -382,7 +382,7 @@
</span><span class="cx"> emitGetVirtualRegister(currentInstruction[1].u.operand, regT0);
</span><span class="cx">
</span><span class="cx"> Jump isZero = branch64(Equal, regT0, TrustedImm64(JSValue::encode(jsNumber(0))));
</span><del>- addJump(emitJumpIfImmediateInteger(regT0), target);
</del><ins>+ addJump(emitJumpIfInt(regT0), target);
</ins><span class="cx">
</span><span class="cx"> addJump(branch64(Equal, regT0, TrustedImm64(JSValue::encode(jsBoolean(true)))), target);
</span><span class="cx"> addSlowCase(branch64(NotEqual, regT0, TrustedImm64(JSValue::encode(jsBoolean(false)))));
</span><span class="lines">@@ -393,9 +393,9 @@
</span><span class="cx"> void JIT::emit_op_neq(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> emitGetVirtualRegisters(currentInstruction[2].u.operand, regT0, currentInstruction[3].u.operand, regT1);
</span><del>- emitJumpSlowCaseIfNotImmediateIntegers(regT0, regT1, regT2);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0, regT1, regT2);
</ins><span class="cx"> compare32(NotEqual, regT1, regT0, regT0);
</span><del>- emitTagAsBoolImmediate(regT0);
</del><ins>+ emitTagBool(regT0);
</ins><span class="cx">
</span><span class="cx"> emitPutVirtualRegister(currentInstruction[1].u.operand);
</span><span class="cx">
</span><span class="lines">@@ -404,16 +404,16 @@
</span><span class="cx"> void JIT::emit_op_bitxor(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> emitGetVirtualRegisters(currentInstruction[2].u.operand, regT0, currentInstruction[3].u.operand, regT1);
</span><del>- emitJumpSlowCaseIfNotImmediateIntegers(regT0, regT1, regT2);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0, regT1, regT2);
</ins><span class="cx"> xor64(regT1, regT0);
</span><del>- emitFastArithReTagImmediate(regT0, regT0);
</del><ins>+ emitTagInt(regT0, regT0);
</ins><span class="cx"> emitPutVirtualRegister(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void JIT::emit_op_bitor(Instruction* currentInstruction)
</span><span class="cx"> {
</span><span class="cx"> emitGetVirtualRegisters(currentInstruction[2].u.operand, regT0, currentInstruction[3].u.operand, regT1);
</span><del>- emitJumpSlowCaseIfNotImmediateIntegers(regT0, regT1, regT2);
</del><ins>+ emitJumpSlowCaseIfNotInt(regT0, regT1, regT2);
</ins><span class="cx"> or64(regT1, regT0);
</span><span class="cx"> emitPutVirtualRegister(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="lines">@@ -448,18 +448,18 @@
</span><span class="cx">
</span><span class="cx"> // Jump slow if either is a double. First test if it's an integer, which is fine, and then test
</span><span class="cx"> // if it's a double.
</span><del>- Jump leftOK = emitJumpIfImmediateInteger(regT0);
- addSlowCase(emitJumpIfImmediateNumber(regT0));
</del><ins>+ Jump leftOK = emitJumpIfInt(regT0);
+ addSlowCase(emitJumpIfNumber(regT0));
</ins><span class="cx"> leftOK.link(this);
</span><del>- Jump rightOK = emitJumpIfImmediateInteger(regT1);
- addSlowCase(emitJumpIfImmediateNumber(regT1));
</del><ins>+ Jump rightOK = emitJumpIfInt(regT1);
+ addSlowCase(emitJumpIfNumber(regT1));
</ins><span class="cx"> rightOK.link(this);
</span><span class="cx">
</span><span class="cx"> if (type == OpStrictEq)
</span><span class="cx"> compare64(Equal, regT1, regT0, regT0);
</span><span class="cx"> else
</span><span class="cx"> compare64(NotEqual, regT1, regT0, regT0);
</span><del>- emitTagAsBoolImmediate(regT0);
</del><ins>+ emitTagBool(regT0);
</ins><span class="cx">
</span><span class="cx"> emitPutVirtualRegister(dst);
</span><span class="cx"> }
</span><span class="lines">@@ -479,7 +479,7 @@
</span><span class="cx"> int srcVReg = currentInstruction[2].u.operand;
</span><span class="cx"> emitGetVirtualRegister(srcVReg, regT0);
</span><span class="cx">
</span><del>- addSlowCase(emitJumpIfNotImmediateNumber(regT0));
</del><ins>+ addSlowCase(emitJumpIfNotNumber(regT0));
</ins><span class="cx">
</span><span class="cx"> emitPutVirtualRegister(currentInstruction[1].u.operand);
</span><span class="cx"> }
</span><span class="lines">@@ -621,7 +621,7 @@
</span><span class="cx"> wasNotImmediate.link(this);
</span><span class="cx"> wasNotMasqueradesAsUndefined.link(this);
</span><span class="cx">
</span><del>- emitTagAsBoolImmediate(regT0);
</del><ins>+ emitTagBool(regT0);
</ins><span class="cx"> emitPutVirtualRegister(dst);
</span><span class="cx">
</span><span class="cx"> }
</span><span class="lines">@@ -653,7 +653,7 @@
</span><span class="cx"> wasNotImmediate.link(this);
</span><span class="cx"> wasNotMasqueradesAsUndefined.link(this);
</span><span class="cx">
</span><del>- emitTagAsBoolImmediate(regT0);
</del><ins>+ emitTagBool(regT0);
</ins><span class="cx"> emitPutVirtualRegister(dst);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -831,7 +831,7 @@
</span><span class="cx"> {
</span><span class="cx"> linkSlowCase(iter);
</span><span class="cx"> callOperation(operationCompareEq, regT0, regT1);
</span><del>- emitTagAsBoolImmediate(returnValueGPR);
</del><ins>+ emitTagBool(returnValueGPR);
</ins><span class="cx"> emitPutVirtualRegister(currentInstruction[1].u.operand, returnValueGPR);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -840,7 +840,7 @@
</span><span class="cx"> linkSlowCase(iter);
</span><span class="cx"> callOperation(operationCompareEq, regT0, regT1);
</span><span class="cx"> xor32(TrustedImm32(0x1), regT0);
</span><del>- emitTagAsBoolImmediate(returnValueGPR);
</del><ins>+ emitTagBool(returnValueGPR);
</ins><span class="cx"> emitPutVirtualRegister(currentInstruction[1].u.operand, returnValueGPR);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1285,9 +1285,9 @@
</span><span class="cx"> and64(TrustedImm32(~1), regT1);
</span><span class="cx"> jumpToEnd.append(branch64(Equal, regT1, TrustedImm64(ValueFalse)));
</span><span class="cx"> } else if (cachedTypeLocation->m_lastSeenType == TypeMachineInt)
</span><del>- jumpToEnd.append(emitJumpIfImmediateInteger(regT0));
</del><ins>+ jumpToEnd.append(emitJumpIfInt(regT0));
</ins><span class="cx"> else if (cachedTypeLocation->m_lastSeenType == TypeNumber)
</span><del>- jumpToEnd.append(emitJumpIfImmediateNumber(regT0));
</del><ins>+ jumpToEnd.append(emitJumpIfNumber(regT0));
</ins><span class="cx"> else if (cachedTypeLocation->m_lastSeenType == TypeString) {
</span><span class="cx"> Jump isNotCell = emitJumpIfNotJSCell(regT0);
</span><span class="cx"> jumpToEnd.append(branch8(Equal, Address(regT0, JSCell::typeInfoTypeOffset()), TrustedImm32(StringType)));
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITOpcodes32_64cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp (190229 => 190230)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp 2015-09-24 23:33:34 UTC (rev 190229)
+++ trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp 2015-09-25 00:17:16 UTC (rev 190230)
</span><span class="lines">@@ -53,7 +53,7 @@
</span><span class="cx"> Call nativeCall;
</span><span class="cx">
</span><span class="cx"> emitFunctionPrologue();
</span><del>- emitPutImmediateToCallFrameHeader(0, JSStack::CodeBlock);
</del><ins>+ emitPutToCallFrameHeader(0, JSStack::CodeBlock);
</ins><span class="cx"> storePtr(callFrameRegister, &m_vm->topCallFrame);
</span><span class="cx">
</span><span class="cx"> #if CPU(X86)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITPropertyAccesscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp (190229 => 190230)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp 2015-09-24 23:33:34 UTC (rev 190229)
+++ trunk/Source/JavaScriptCore/jit/JITPropertyAccess.cpp 2015-09-25 00:17:16 UTC (rev 190230)
</span><span class="lines">@@ -104,7 +104,7 @@
</span><span class="cx">
</span><span class="cx"> emitJumpSlowCaseIfNotJSCell(regT0, base);
</span><span class="cx">
</span><del>- PatchableJump notIndex = emitPatchableJumpIfNotImmediateInteger(regT1);
</del><ins>+ PatchableJump notIndex = emitPatchableJumpIfNotInt(regT1);
</ins><span class="cx"> addSlowCase(notIndex);
</span><span class="cx">
</span><span class="cx"> // This is technically incorrect - we're zero-extending an int32. On the hot path this doesn't matter.
</span><span class="lines">@@ -301,7 +301,7 @@
</span><span class="cx">
</span><span class="cx"> emitGetVirtualRegisters(base, regT0, property, regT1);
</span><span class="cx"> emitJumpSlowCaseIfNotJSCell(regT0, base);
</span><del>- PatchableJump notIndex = emitPatchableJumpIfNotImmediateInteger(regT1);
</del><ins>+ PatchableJump notIndex = emitPatchableJumpIfNotInt(regT1);
</ins><span class="cx"> addSlowCase(notIndex);
</span><span class="cx"> // See comment in op_get_by_val.
</span><span class="cx"> zeroExtend32ToPtr(regT1, regT1);
</span><span class="lines">@@ -354,11 +354,11 @@
</span><span class="cx"> emitGetVirtualRegister(value, regT3);
</span><span class="cx"> switch (indexingShape) {
</span><span class="cx"> case Int32Shape:
</span><del>- slowCases.append(emitJumpIfNotImmediateInteger(regT3));
</del><ins>+ slowCases.append(emitJumpIfNotInt(regT3));
</ins><span class="cx"> store64(regT3, BaseIndex(regT2, regT1, TimesEight));
</span><span class="cx"> break;
</span><span class="cx"> case DoubleShape: {
</span><del>- Jump notInt = emitJumpIfNotImmediateInteger(regT3);
</del><ins>+ Jump notInt = emitJumpIfNotInt(regT3);
</ins><span class="cx"> convertInt32ToDouble(regT3, fpRegT0);
</span><span class="cx"> Jump ready = jump();
</span><span class="cx"> notInt.link(this);
</span><span class="lines">@@ -617,7 +617,6 @@
</span><span class="cx">
</span><span class="cx"> emitGetVirtualRegisters(baseVReg, regT0, valueVReg, regT1);
</span><span class="cx">
</span><del>- // Jump to a slow case if either the base object is an immediate, or if the Structure does not match.
</del><span class="cx"> emitJumpSlowCaseIfNotJSCell(regT0, baseVReg);
</span><span class="cx">
</span><span class="cx"> JITPutByIdGenerator gen(
</span><span class="lines">@@ -1630,7 +1629,7 @@
</span><span class="cx">
</span><span class="cx"> #if USE(JSVALUE64)
</span><span class="cx"> emitGetVirtualRegister(value, earlyScratch);
</span><del>- slowCases.append(emitJumpIfNotImmediateInteger(earlyScratch));
</del><ins>+ slowCases.append(emitJumpIfNotInt(earlyScratch));
</ins><span class="cx"> #else
</span><span class="cx"> emitLoad(value, lateScratch, earlyScratch);
</span><span class="cx"> slowCases.append(branch32(NotEqual, lateScratch, TrustedImm32(JSValue::Int32Tag)));
</span><span class="lines">@@ -1702,11 +1701,11 @@
</span><span class="cx">
</span><span class="cx"> #if USE(JSVALUE64)
</span><span class="cx"> emitGetVirtualRegister(value, earlyScratch);
</span><del>- Jump doubleCase = emitJumpIfNotImmediateInteger(earlyScratch);
</del><ins>+ Jump doubleCase = emitJumpIfNotInt(earlyScratch);
</ins><span class="cx"> convertInt32ToDouble(earlyScratch, fpRegT0);
</span><span class="cx"> Jump ready = jump();
</span><span class="cx"> doubleCase.link(this);
</span><del>- slowCases.append(emitJumpIfNotImmediateNumber(earlyScratch));
</del><ins>+ slowCases.append(emitJumpIfNotNumber(earlyScratch));
</ins><span class="cx"> add64(tagTypeNumberRegister, earlyScratch);
</span><span class="cx"> move64ToDouble(earlyScratch, fpRegT0);
</span><span class="cx"> ready.link(this);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJSInterfaceJITh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JSInterfaceJIT.h (190229 => 190230)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JSInterfaceJIT.h 2015-09-24 23:33:34 UTC (rev 190229)
+++ trunk/Source/JavaScriptCore/jit/JSInterfaceJIT.h 2015-09-25 00:17:16 UTC (rev 190230)
</span><span class="lines">@@ -65,17 +65,16 @@
</span><span class="cx">
</span><span class="cx"> #if USE(JSVALUE64)
</span><span class="cx"> Jump emitJumpIfNotJSCell(RegisterID);
</span><del>- Jump emitJumpIfImmediateNumber(RegisterID reg);
- Jump emitJumpIfNotImmediateNumber(RegisterID reg);
- void emitFastArithImmToInt(RegisterID reg);
- void emitFastArithIntToImmNoCheck(RegisterID src, RegisterID dest);
</del><ins>+ Jump emitJumpIfNumber(RegisterID);
+ Jump emitJumpIfNotNumber(RegisterID);
+ void emitTagInt(RegisterID src, RegisterID dest);
</ins><span class="cx"> #endif
</span><span class="cx">
</span><span class="cx"> Jump emitJumpIfNotType(RegisterID baseReg, JSType);
</span><span class="cx">
</span><span class="cx"> void emitGetFromCallFrameHeaderPtr(JSStack::CallFrameHeaderEntry, RegisterID to, RegisterID from = callFrameRegister);
</span><span class="cx"> void emitPutToCallFrameHeader(RegisterID from, JSStack::CallFrameHeaderEntry);
</span><del>- void emitPutImmediateToCallFrameHeader(void* value, JSStack::CallFrameHeaderEntry);
</del><ins>+ void emitPutToCallFrameHeader(void* value, JSStack::CallFrameHeaderEntry);
</ins><span class="cx"> void emitPutCellToCallFrameHeader(RegisterID from, JSStack::CallFrameHeaderEntry);
</span><span class="cx">
</span><span class="cx"> inline Address payloadFor(int index, RegisterID base = callFrameRegister);
</span><span class="lines">@@ -154,11 +153,11 @@
</span><span class="cx"> return branchTest64(NonZero, reg, tagMaskRegister);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- ALWAYS_INLINE JSInterfaceJIT::Jump JSInterfaceJIT::emitJumpIfImmediateNumber(RegisterID reg)
</del><ins>+ ALWAYS_INLINE JSInterfaceJIT::Jump JSInterfaceJIT::emitJumpIfNumber(RegisterID reg)
</ins><span class="cx"> {
</span><span class="cx"> return branchTest64(NonZero, reg, tagTypeNumberRegister);
</span><span class="cx"> }
</span><del>- ALWAYS_INLINE JSInterfaceJIT::Jump JSInterfaceJIT::emitJumpIfNotImmediateNumber(RegisterID reg)
</del><ins>+ ALWAYS_INLINE JSInterfaceJIT::Jump JSInterfaceJIT::emitJumpIfNotNumber(RegisterID reg)
</ins><span class="cx"> {
</span><span class="cx"> return branchTest64(Zero, reg, tagTypeNumberRegister);
</span><span class="cx"> }
</span><span class="lines">@@ -179,7 +178,7 @@
</span><span class="cx"> inline JSInterfaceJIT::Jump JSInterfaceJIT::emitLoadDouble(unsigned virtualRegisterIndex, FPRegisterID dst, RegisterID scratch)
</span><span class="cx"> {
</span><span class="cx"> load64(addressFor(virtualRegisterIndex), scratch);
</span><del>- Jump notNumber = emitJumpIfNotImmediateNumber(scratch);
</del><ins>+ Jump notNumber = emitJumpIfNotNumber(scratch);
</ins><span class="cx"> Jump notInt = branch64(Below, scratch, tagTypeNumberRegister);
</span><span class="cx"> convertInt32ToDouble(scratch, dst);
</span><span class="cx"> Jump done = jump();
</span><span class="lines">@@ -190,12 +189,8 @@
</span><span class="cx"> return notNumber;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- ALWAYS_INLINE void JSInterfaceJIT::emitFastArithImmToInt(RegisterID)
- {
- }
-
</del><span class="cx"> // operand is int32_t, must have been zero-extended if register is 64-bit.
</span><del>- ALWAYS_INLINE void JSInterfaceJIT::emitFastArithIntToImmNoCheck(RegisterID src, RegisterID dest)
</del><ins>+ ALWAYS_INLINE void JSInterfaceJIT::emitTagInt(RegisterID src, RegisterID dest)
</ins><span class="cx"> {
</span><span class="cx"> if (src != dest)
</span><span class="cx"> move(src, dest);
</span><span class="lines">@@ -241,7 +236,7 @@
</span><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx">
</span><del>- ALWAYS_INLINE void JSInterfaceJIT::emitPutImmediateToCallFrameHeader(void* value, JSStack::CallFrameHeaderEntry entry)
</del><ins>+ ALWAYS_INLINE void JSInterfaceJIT::emitPutToCallFrameHeader(void* value, JSStack::CallFrameHeaderEntry entry)
</ins><span class="cx"> {
</span><span class="cx"> storePtr(TrustedImmPtr(value), Address(callFrameRegister, entry * sizeof(Register)));
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitThunkGeneratorscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp (190229 => 190230)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp 2015-09-24 23:33:34 UTC (rev 190229)
+++ trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp 2015-09-25 00:17:16 UTC (rev 190230)
</span><span class="lines">@@ -257,7 +257,7 @@
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- jit.emitPutImmediateToCallFrameHeader(0, JSStack::CodeBlock);
</del><ins>+ jit.emitPutToCallFrameHeader(0, JSStack::CodeBlock);
</ins><span class="cx"> jit.storePtr(JSInterfaceJIT::callFrameRegister, &vm->topCallFrame);
</span><span class="cx">
</span><span class="cx"> #if CPU(X86)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorewasmWASMFunctionCompilerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/wasm/WASMFunctionCompiler.h (190229 => 190230)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/wasm/WASMFunctionCompiler.h 2015-09-24 23:33:34 UTC (rev 190229)
+++ trunk/Source/JavaScriptCore/wasm/WASMFunctionCompiler.h 2015-09-25 00:17:16 UTC (rev 190230)
</span><span class="lines">@@ -128,7 +128,7 @@
</span><span class="cx"> m_codeBlock->setCalleeSaveRegisters(RegisterSet::webAssemblyCalleeSaveRegisters());
</span><span class="cx">
</span><span class="cx"> emitFunctionPrologue();
</span><del>- emitPutImmediateToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);
</del><ins>+ emitPutToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);
</ins><span class="cx">
</span><span class="cx"> m_beginLabel = label();
</span><span class="cx">
</span><span class="lines">@@ -215,7 +215,7 @@
</span><span class="cx"> // FIXME: Implement arity check.
</span><span class="cx"> Label arityCheck = label();
</span><span class="cx"> emitFunctionPrologue();
</span><del>- emitPutImmediateToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);
</del><ins>+ emitPutToCallFrameHeader(m_codeBlock, JSStack::CodeBlock);
</ins><span class="cx"> jump(m_beginLabel);
</span><span class="cx">
</span><span class="cx"> if (!m_divideErrorJumpList.empty()) {
</span></span></pre>
</div>
</div>
</body>
</html>