<!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>[151345] branches/dfgFourthTier/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/151345">151345</a></dd>
<dt>Author</dt> <dd>fpizlo@apple.com</dd>
<dt>Date</dt> <dd>2013-06-07 19:11:54 -0700 (Fri, 07 Jun 2013)</dd>
</dl>

<h3>Log Message</h3>
<pre>Unreviewed, roll out http://trac.webkit.org/changeset/151342
It broke Kraken crypto tests in debug build. That results in a pretty bad
loss of test coverage.

* JavaScriptCore.xcodeproj/project.pbxproj:
* jit/JIT.cpp:
(JSC):
(JSC::JIT::privateCompileMainPass):
* jit/JIT.h:
(JIT):
* jit/JITArithmetic.cpp:
(JSC::JIT::emitSlow_op_negate):
(JSC::JIT::emitSlow_op_lshift):
(JSC::JIT::emitSlow_op_rshift):
(JSC::JIT::emitSlow_op_urshift):
(JSC::JIT::emitSlow_op_bitand):
(JSC::JIT::emitSlow_op_inc):
(JSC::JIT::emitSlow_op_dec):
(JSC::JIT::emitSlow_op_mod):
(JSC::JIT::emit_op_mod):
(JSC::JIT::compileBinaryArithOpSlowCase):
(JSC::JIT::emit_op_add):
(JSC::JIT::emitSlow_op_add):
(JSC::JIT::emitSlow_op_mul):
(JSC::JIT::emitSlow_op_div):
(JSC::JIT::emitSlow_op_sub):
* jit/JITArithmetic32_64.cpp:
(JSC::JIT::emitSlow_op_negate):
(JSC::JIT::emitSlow_op_lshift):
(JSC::JIT::emitRightShiftSlowCase):
(JSC::JIT::emitSlow_op_bitand):
(JSC::JIT::emitSlow_op_bitor):
(JSC::JIT::emitSlow_op_bitxor):
(JSC::JIT::emitSlow_op_inc):
(JSC::JIT::emitSlow_op_dec):
(JSC::JIT::emit_op_add):
(JSC::JIT::emitSlow_op_add):
(JSC::JIT::emitSlow_op_sub):
(JSC::JIT::emitSlow_op_mul):
(JSC::JIT::emitSlow_op_div):
(JSC::JIT::emit_op_mod):
(JSC::JIT::emitSlow_op_mod):
* jit/JITExceptions.cpp:
(JSC):
(JSC::genericThrow):
* jit/JITExceptions.h:
(ExceptionHandler):
(JSC):
* jit/JITOpcodes.cpp:
(JSC::JIT::emit_op_strcat):
(JSC::JIT::emitSlow_op_create_this):
(JSC::JIT::emitSlow_op_to_this):
(JSC::JIT::emitSlow_op_to_primitive):
(JSC::JIT::emitSlow_op_not):
(JSC::JIT::emitSlow_op_bitxor):
(JSC::JIT::emitSlow_op_bitor):
(JSC::JIT::emitSlow_op_stricteq):
(JSC::JIT::emitSlow_op_nstricteq):
(JSC::JIT::emitSlow_op_to_number):
* jit/JITOpcodes32_64.cpp:
(JSC::JIT::privateCompileCTINativeCall):
(JSC::JIT::emitSlow_op_to_primitive):
(JSC::JIT::emit_op_strcat):
(JSC::JIT::emitSlow_op_not):
(JSC::JIT::emitSlow_op_stricteq):
(JSC::JIT::emitSlow_op_nstricteq):
(JSC::JIT::emitSlow_op_to_number):
(JSC::JIT::emit_op_create_arguments):
(JSC::JIT::emitSlow_op_create_this):
(JSC::JIT::emitSlow_op_to_this):
(JSC::JIT::emitSlow_op_get_argument_by_val):
* jit/JITStubs.cpp:
(JSC::DEFINE_STUB_FUNCTION):
(JSC):
* jit/JITStubs.h:
(JSC):
* jit/JITStubsARM.h:
(JSC):
* jit/JITStubsARMv7.h:
(JSC):
* jit/JITStubsMIPS.h:
(JSC):
* jit/JITStubsSH4.h:
(JSC):
* jit/JITStubsX86.h:
(JSC):
* jit/JITStubsX86_64.h:
(JSC):
* jit/JSInterfaceJIT.h:
(JSInterfaceJIT):
* jit/SlowPathCall.h: Removed.
* jit/ThunkGenerators.cpp:
(JSC::nativeForGenerator):
* llint/LLIntSlowPaths.cpp:
(JSC::LLInt::LLINT_SLOW_PATH_DECL):
(LLInt):
* llint/LLIntSlowPaths.h:
(LLInt):
(SlowPathReturnType):
(JSC::LLInt::encodeResult):
(JSC::LLInt::decodeResult):
* llint/LowLevelInterpreter.asm:
* llint/LowLevelInterpreter.cpp:
* llint/LowLevelInterpreter32_64.asm:
* llint/LowLevelInterpreter64.asm:
* runtime/CommonSlowPaths.cpp: Removed.
* runtime/CommonSlowPaths.h:
* runtime/JSCJSValue.h:
(JSValue):</pre>

<h3>Modified Paths</h3>
<ul>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCoreChangeLog">branches/dfgFourthTier/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCoreJavaScriptCorexcodeprojprojectpbxproj">branches/dfgFourthTier/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJITcpp">branches/dfgFourthTier/Source/JavaScriptCore/jit/JIT.cpp</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJITh">branches/dfgFourthTier/Source/JavaScriptCore/jit/JIT.h</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJITArithmeticcpp">branches/dfgFourthTier/Source/JavaScriptCore/jit/JITArithmetic.cpp</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJITArithmetic32_64cpp">branches/dfgFourthTier/Source/JavaScriptCore/jit/JITArithmetic32_64.cpp</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJITExceptionscpp">branches/dfgFourthTier/Source/JavaScriptCore/jit/JITExceptions.cpp</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJITExceptionsh">branches/dfgFourthTier/Source/JavaScriptCore/jit/JITExceptions.h</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJITOpcodescpp">branches/dfgFourthTier/Source/JavaScriptCore/jit/JITOpcodes.cpp</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJITOpcodes32_64cpp">branches/dfgFourthTier/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJITStubscpp">branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubs.cpp</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJITStubsh">branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubs.h</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJITStubsARMh">branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsARM.h</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJITStubsARMv7h">branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsARMv7.h</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJITStubsMIPSh">branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsMIPS.h</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJITStubsSH4h">branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsSH4.h</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJITStubsX86h">branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsX86.h</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJITStubsX86_64h">branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsX86_64.h</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitJSInterfaceJITh">branches/dfgFourthTier/Source/JavaScriptCore/jit/JSInterfaceJIT.h</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitThunkGeneratorscpp">branches/dfgFourthTier/Source/JavaScriptCore/jit/ThunkGenerators.cpp</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorellintLLIntSlowPathscpp">branches/dfgFourthTier/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorellintLLIntSlowPathsh">branches/dfgFourthTier/Source/JavaScriptCore/llint/LLIntSlowPaths.h</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorellintLowLevelInterpreterasm">branches/dfgFourthTier/Source/JavaScriptCore/llint/LowLevelInterpreter.asm</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorellintLowLevelInterpretercpp">branches/dfgFourthTier/Source/JavaScriptCore/llint/LowLevelInterpreter.cpp</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorellintLowLevelInterpreter32_64asm">branches/dfgFourthTier/Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorellintLowLevelInterpreter64asm">branches/dfgFourthTier/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCoreruntimeCommonSlowPathsh">branches/dfgFourthTier/Source/JavaScriptCore/runtime/CommonSlowPaths.h</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCoreruntimeJSCJSValueh">branches/dfgFourthTier/Source/JavaScriptCore/runtime/JSCJSValue.h</a></li>
</ul>

<h3>Removed Paths</h3>
<ul>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCorejitSlowPathCallh">branches/dfgFourthTier/Source/JavaScriptCore/jit/SlowPathCall.h</a></li>
<li><a href="#branchesdfgFourthTierSourceJavaScriptCoreruntimeCommonSlowPathscpp">branches/dfgFourthTier/Source/JavaScriptCore/runtime/CommonSlowPaths.cpp</a></li>
</ul>

</div>
<div id="patch">
<h3>Diff</h3>
<a id="branchesdfgFourthTierSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/ChangeLog (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/ChangeLog        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/ChangeLog        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -1,5 +1,117 @@
</span><span class="cx"> 2013-06-07  Filip Pizlo  &lt;fpizlo@apple.com&gt;
</span><span class="cx"> 
</span><ins>+        Unreviewed, roll out http://trac.webkit.org/changeset/151342
+        It broke Kraken crypto tests in debug build. That results in a pretty bad
+        loss of test coverage.
+
+        * JavaScriptCore.xcodeproj/project.pbxproj:
+        * jit/JIT.cpp:
+        (JSC):
+        (JSC::JIT::privateCompileMainPass):
+        * jit/JIT.h:
+        (JIT):
+        * jit/JITArithmetic.cpp:
+        (JSC::JIT::emitSlow_op_negate):
+        (JSC::JIT::emitSlow_op_lshift):
+        (JSC::JIT::emitSlow_op_rshift):
+        (JSC::JIT::emitSlow_op_urshift):
+        (JSC::JIT::emitSlow_op_bitand):
+        (JSC::JIT::emitSlow_op_inc):
+        (JSC::JIT::emitSlow_op_dec):
+        (JSC::JIT::emitSlow_op_mod):
+        (JSC::JIT::emit_op_mod):
+        (JSC::JIT::compileBinaryArithOpSlowCase):
+        (JSC::JIT::emit_op_add):
+        (JSC::JIT::emitSlow_op_add):
+        (JSC::JIT::emitSlow_op_mul):
+        (JSC::JIT::emitSlow_op_div):
+        (JSC::JIT::emitSlow_op_sub):
+        * jit/JITArithmetic32_64.cpp:
+        (JSC::JIT::emitSlow_op_negate):
+        (JSC::JIT::emitSlow_op_lshift):
+        (JSC::JIT::emitRightShiftSlowCase):
+        (JSC::JIT::emitSlow_op_bitand):
+        (JSC::JIT::emitSlow_op_bitor):
+        (JSC::JIT::emitSlow_op_bitxor):
+        (JSC::JIT::emitSlow_op_inc):
+        (JSC::JIT::emitSlow_op_dec):
+        (JSC::JIT::emit_op_add):
+        (JSC::JIT::emitSlow_op_add):
+        (JSC::JIT::emitSlow_op_sub):
+        (JSC::JIT::emitSlow_op_mul):
+        (JSC::JIT::emitSlow_op_div):
+        (JSC::JIT::emit_op_mod):
+        (JSC::JIT::emitSlow_op_mod):
+        * jit/JITExceptions.cpp:
+        (JSC):
+        (JSC::genericThrow):
+        * jit/JITExceptions.h:
+        (ExceptionHandler):
+        (JSC):
+        * jit/JITOpcodes.cpp:
+        (JSC::JIT::emit_op_strcat):
+        (JSC::JIT::emitSlow_op_create_this):
+        (JSC::JIT::emitSlow_op_to_this):
+        (JSC::JIT::emitSlow_op_to_primitive):
+        (JSC::JIT::emitSlow_op_not):
+        (JSC::JIT::emitSlow_op_bitxor):
+        (JSC::JIT::emitSlow_op_bitor):
+        (JSC::JIT::emitSlow_op_stricteq):
+        (JSC::JIT::emitSlow_op_nstricteq):
+        (JSC::JIT::emitSlow_op_to_number):
+        * jit/JITOpcodes32_64.cpp:
+        (JSC::JIT::privateCompileCTINativeCall):
+        (JSC::JIT::emitSlow_op_to_primitive):
+        (JSC::JIT::emit_op_strcat):
+        (JSC::JIT::emitSlow_op_not):
+        (JSC::JIT::emitSlow_op_stricteq):
+        (JSC::JIT::emitSlow_op_nstricteq):
+        (JSC::JIT::emitSlow_op_to_number):
+        (JSC::JIT::emit_op_create_arguments):
+        (JSC::JIT::emitSlow_op_create_this):
+        (JSC::JIT::emitSlow_op_to_this):
+        (JSC::JIT::emitSlow_op_get_argument_by_val):
+        * jit/JITStubs.cpp:
+        (JSC::DEFINE_STUB_FUNCTION):
+        (JSC):
+        * jit/JITStubs.h:
+        (JSC):
+        * jit/JITStubsARM.h:
+        (JSC):
+        * jit/JITStubsARMv7.h:
+        (JSC):
+        * jit/JITStubsMIPS.h:
+        (JSC):
+        * jit/JITStubsSH4.h:
+        (JSC):
+        * jit/JITStubsX86.h:
+        (JSC):
+        * jit/JITStubsX86_64.h:
+        (JSC):
+        * jit/JSInterfaceJIT.h:
+        (JSInterfaceJIT):
+        * jit/SlowPathCall.h: Removed.
+        * jit/ThunkGenerators.cpp:
+        (JSC::nativeForGenerator):
+        * llint/LLIntSlowPaths.cpp:
+        (JSC::LLInt::LLINT_SLOW_PATH_DECL):
+        (LLInt):
+        * llint/LLIntSlowPaths.h:
+        (LLInt):
+        (SlowPathReturnType):
+        (JSC::LLInt::encodeResult):
+        (JSC::LLInt::decodeResult):
+        * llint/LowLevelInterpreter.asm:
+        * llint/LowLevelInterpreter.cpp:
+        * llint/LowLevelInterpreter32_64.asm:
+        * llint/LowLevelInterpreter64.asm:
+        * runtime/CommonSlowPaths.cpp: Removed.
+        * runtime/CommonSlowPaths.h:
+        * runtime/JSCJSValue.h:
+        (JSValue):
+
+2013-06-07  Filip Pizlo  &lt;fpizlo@apple.com&gt;
+
</ins><span class="cx">         fourthTier: don't insert ForceOSRExits except for inadequate coverage
</span><span class="cx">         https://bugs.webkit.org/show_bug.cgi?id=117363
</span><span class="cx"> 
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCoreJavaScriptCorexcodeprojprojectpbxproj"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -611,7 +611,6 @@
</span><span class="cx">                 651122FD14046A4C002B101D /* JavaScriptCore.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 932F5BD90822A1C700736975 /* JavaScriptCore.framework */; };
</span><span class="cx">                 651122FE14046A4C002B101D /* libedit.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = 5D5D8AD00E0D0EBE00F9C692 /* libedit.dylib */; };
</span><span class="cx">                 6511230714046B0A002B101D /* testRegExp.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 651122E5140469BA002B101D /* testRegExp.cpp */; };
</span><del>-                6519976E17443D68007393CE /* CommonSlowPaths.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6519976C17443548007393CE /* CommonSlowPaths.cpp */; };
</del><span class="cx">                 65303D641447B9E100D3F904 /* ParserTokens.h in Headers */ = {isa = PBXBuildFile; fileRef = 65303D631447B9E100D3F904 /* ParserTokens.h */; settings = {ATTRIBUTES = (Private, ); }; };
</span><span class="cx">                 655EB29B10CE2581001A990E /* NodesCodegen.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 655EB29A10CE2581001A990E /* NodesCodegen.cpp */; };
</span><span class="cx">                 7E4EE7090EBB7963005934AA /* StructureChain.h in Headers */ = {isa = PBXBuildFile; fileRef = 7E4EE7080EBB7963005934AA /* StructureChain.h */; settings = {ATTRIBUTES = (Private, ); }; };
</span><span class="lines">@@ -1584,7 +1583,6 @@
</span><span class="cx">                 6507D2970E871E4A00D7D896 /* JSTypeInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSTypeInfo.h; sourceTree = &quot;&lt;group&gt;&quot;; };
</span><span class="cx">                 651122E5140469BA002B101D /* testRegExp.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = testRegExp.cpp; sourceTree = &quot;&lt;group&gt;&quot;; };
</span><span class="cx">                 6511230514046A4C002B101D /* testRegExp */ = {isa = PBXFileReference; explicitFileType = &quot;compiled.mach-o.executable&quot;; includeInIndex = 0; path = testRegExp; sourceTree = BUILT_PRODUCTS_DIR; };
</span><del>-                6519976C17443548007393CE /* CommonSlowPaths.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = CommonSlowPaths.cpp; sourceTree = &quot;&lt;group&gt;&quot;; };
</del><span class="cx">                 65303D631447B9E100D3F904 /* ParserTokens.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ParserTokens.h; sourceTree = &quot;&lt;group&gt;&quot;; };
</span><span class="cx">                 65400C0F0A69BAF200509887 /* PropertyNameArray.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = PropertyNameArray.cpp; sourceTree = &quot;&lt;group&gt;&quot;; };
</span><span class="cx">                 65400C100A69BAF200509887 /* PropertyNameArray.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = PropertyNameArray.h; sourceTree = &quot;&lt;group&gt;&quot;; };
</span><span class="lines">@@ -1594,7 +1592,6 @@
</span><span class="cx">                 65621E6C089E859700760F35 /* PropertySlot.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = PropertySlot.h; sourceTree = &quot;&lt;group&gt;&quot;; tabWidth = 8; };
</span><span class="cx">                 65987F2C167FE84B003C2F8D /* DFGOSRExitCompilationInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DFGOSRExitCompilationInfo.h; path = dfg/DFGOSRExitCompilationInfo.h; sourceTree = &quot;&lt;group&gt;&quot;; };
</span><span class="cx">                 65987F2F16828A7E003C2F8D /* UnusedPointer.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = UnusedPointer.h; sourceTree = &quot;&lt;group&gt;&quot;; };
</span><del>-                65AC83F1174C17AE0011D8AB /* SlowPathCall.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SlowPathCall.h; sourceTree = &quot;&lt;group&gt;&quot;; };
</del><span class="cx">                 65C02FBB0637462A003E7EE6 /* Protect.h */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.c.h; path = Protect.h; sourceTree = &quot;&lt;group&gt;&quot;; tabWidth = 8; };
</span><span class="cx">                 65C7A1710A8EAACB00FA37EA /* JSWrapperObject.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JSWrapperObject.cpp; sourceTree = &quot;&lt;group&gt;&quot;; };
</span><span class="cx">                 65C7A1720A8EAACB00FA37EA /* JSWrapperObject.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JSWrapperObject.h; sourceTree = &quot;&lt;group&gt;&quot;; };
</span><span class="lines">@@ -2295,7 +2292,6 @@
</span><span class="cx">                 1429D92C0ED22D7000B89619 /* jit */ = {
</span><span class="cx">                         isa = PBXGroup;
</span><span class="cx">                         children = (
</span><del>-                                65AC83F1174C17AE0011D8AB /* SlowPathCall.h */,
</del><span class="cx">                                 0F73D7AB165A142A00ACAB71 /* ClosureCallStubRoutine.cpp */,
</span><span class="cx">                                 0F73D7AC165A142A00ACAB71 /* ClosureCallStubRoutine.h */,
</span><span class="cx">                                 0FD82E37141AB14200179C94 /* CompactJITCodeMap.h */,
</span><span class="lines">@@ -2624,7 +2620,6 @@
</span><span class="cx">                 7EF6E0BB0EB7A1EC0079AFAF /* runtime */ = {
</span><span class="cx">                         isa = PBXGroup;
</span><span class="cx">                         children = (
</span><del>-                                6519976C17443548007393CE /* CommonSlowPaths.cpp */,
</del><span class="cx">                                 BCF605110E203EF800B9A64D /* ArgList.cpp */,
</span><span class="cx">                                 BCF605120E203EF800B9A64D /* ArgList.h */,
</span><span class="cx">                                 BC257DE50E1F51C50016B6C9 /* Arguments.cpp */,
</span><span class="lines">@@ -4123,7 +4118,6 @@
</span><span class="cx">                         isa = PBXSourcesBuildPhase;
</span><span class="cx">                         buildActionMask = 2147483647;
</span><span class="cx">                         files = (
</span><del>-                                6519976E17443D68007393CE /* CommonSlowPaths.cpp in Sources */,
</del><span class="cx">                                 0F55F0F414D1063900AC7649 /* AbstractPC.cpp in Sources */,
</span><span class="cx">                                 147F39BD107EC37600427A48 /* ArgList.cpp in Sources */,
</span><span class="cx">                                 147F39BE107EC37600427A48 /* Arguments.cpp in Sources */,
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJITcpp"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JIT.cpp (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JIT.cpp        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JIT.cpp        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -46,7 +46,6 @@
</span><span class="cx"> #include &quot;RepatchBuffer.h&quot;
</span><span class="cx"> #include &quot;ResultType.h&quot;
</span><span class="cx"> #include &quot;SamplingTool.h&quot;
</span><del>-#include &quot;SlowPathCall.h&quot;
</del><span class="cx"> #include &lt;wtf/CryptographicallyRandomNumber.h&gt;
</span><span class="cx"> 
</span><span class="cx"> using namespace std;
</span><span class="lines">@@ -124,33 +123,39 @@
</span><span class="cx"> 
</span><span class="cx"> #if USE(JSVALUE32_64)
</span><span class="cx"> #define DEFINE_BINARY_OP(name) \
</span><del>-    case op_##name: { \
-        JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_##name); \
-        slowPathCall.call(); \
-        NEXT_OPCODE(op_##name); \
</del><ins>+    case name: { \
+        JITStubCall stubCall(this, cti_##name); \
+        stubCall.addArgument(currentInstruction[2].u.operand); \
+        stubCall.addArgument(currentInstruction[3].u.operand); \
+        stubCall.call(currentInstruction[1].u.operand); \
+        NEXT_OPCODE(name); \
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx"> #define DEFINE_UNARY_OP(name) \
</span><del>-    case op_##name: { \
-        JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_##name); \
-        slowPathCall.call(); \
-        NEXT_OPCODE(op_##name); \
</del><ins>+    case name: { \
+        JITStubCall stubCall(this, cti_##name); \
+        stubCall.addArgument(currentInstruction[2].u.operand); \
+        stubCall.call(currentInstruction[1].u.operand); \
+        NEXT_OPCODE(name); \
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx"> #else // USE(JSVALUE32_64)
</span><span class="cx"> 
</span><span class="cx"> #define DEFINE_BINARY_OP(name) \
</span><del>-    case op_##name: { \
-        JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_##name); \
-        slowPathCall.call(); \
-        NEXT_OPCODE(op_##name); \
</del><ins>+    case name: { \
+        JITStubCall stubCall(this, cti_##name); \
+        stubCall.addArgument(currentInstruction[2].u.operand, regT2); \
+        stubCall.addArgument(currentInstruction[3].u.operand, regT2); \
+        stubCall.call(currentInstruction[1].u.operand); \
+        NEXT_OPCODE(name); \
</ins><span class="cx">     }
</span><span class="cx"> 
</span><span class="cx"> #define DEFINE_UNARY_OP(name) \
</span><del>-    case op_##name: { \
-        JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_##name); \
-        slowPathCall.call(); \
-        NEXT_OPCODE(op_##name); \
</del><ins>+    case name: { \
+        JITStubCall stubCall(this, cti_##name); \
+        stubCall.addArgument(currentInstruction[2].u.operand, regT2); \
+        stubCall.call(currentInstruction[1].u.operand); \
+        NEXT_OPCODE(name); \
</ins><span class="cx">     }
</span><span class="cx"> #endif // USE(JSVALUE32_64)
</span><span class="cx"> 
</span><span class="lines">@@ -206,15 +211,15 @@
</span><span class="cx">         }
</span><span class="cx"> 
</span><span class="cx">         switch (opcodeID) {
</span><del>-        DEFINE_BINARY_OP(del_by_val)
-        DEFINE_BINARY_OP(in)
-        DEFINE_BINARY_OP(less)
-        DEFINE_BINARY_OP(lesseq)
-        DEFINE_BINARY_OP(greater)
-        DEFINE_BINARY_OP(greatereq)
-        DEFINE_UNARY_OP(is_function)
-        DEFINE_UNARY_OP(is_object)
-        DEFINE_UNARY_OP(typeof)
</del><ins>+        DEFINE_BINARY_OP(op_del_by_val)
+        DEFINE_BINARY_OP(op_in)
+        DEFINE_BINARY_OP(op_less)
+        DEFINE_BINARY_OP(op_lesseq)
+        DEFINE_BINARY_OP(op_greater)
+        DEFINE_BINARY_OP(op_greatereq)
+        DEFINE_UNARY_OP(op_is_function)
+        DEFINE_UNARY_OP(op_is_object)
+        DEFINE_UNARY_OP(op_typeof)
</ins><span class="cx"> 
</span><span class="cx">         DEFINE_OP(op_add)
</span><span class="cx">         DEFINE_OP(op_bitand)
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJITh"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JIT.h (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JIT.h        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JIT.h        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -283,7 +283,6 @@
</span><span class="cx">     void ctiPatchCallByReturnAddress(CodeBlock* codeblock, ReturnAddressPtr returnAddress, FunctionPtr newCalleeFunction);
</span><span class="cx"> 
</span><span class="cx">     class JIT : private JSInterfaceJIT {
</span><del>-        friend class JITSlowPathCall;
</del><span class="cx">         friend class JITStubCall;
</span><span class="cx">         friend struct PropertyStubCompilationInfo;
</span><span class="cx"> 
</span><span class="lines">@@ -610,7 +609,7 @@
</span><span class="cx"> 
</span><span class="cx">         void emitTagAsBoolImmediate(RegisterID reg);
</span><span class="cx">         void compileBinaryArithOp(OpcodeID, unsigned dst, unsigned src1, unsigned src2, OperandTypes opi);
</span><del>-        void compileBinaryArithOpSlowCase(Instruction*, OpcodeID, Vector&lt;SlowCaseEntry&gt;::iterator&amp;, unsigned dst, unsigned src1, unsigned src2, OperandTypes, bool op1HasImmediateIntFastCase, bool op2HasImmediateIntFastCase);
</del><ins>+        void compileBinaryArithOpSlowCase(OpcodeID, Vector&lt;SlowCaseEntry&gt;::iterator&amp;, unsigned dst, unsigned src1, unsigned src2, OperandTypes, bool op1HasImmediateIntFastCase, bool op2HasImmediateIntFastCase);
</ins><span class="cx"> 
</span><span class="cx">         void compileGetByIdHotPath(int baseVReg, Identifier*);
</span><span class="cx">         void compileGetByIdSlowCase(int resultVReg, int baseVReg, Identifier*, Vector&lt;SlowCaseEntry&gt;::iterator&amp;);
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJITArithmeticcpp"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JITArithmetic.cpp (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JITArithmetic.cpp        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JITArithmetic.cpp        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -38,7 +38,6 @@
</span><span class="cx"> #include &quot;Operations.h&quot;
</span><span class="cx"> #include &quot;ResultType.h&quot;
</span><span class="cx"> #include &quot;SamplingTool.h&quot;
</span><del>-#include &quot;SlowPathCall.h&quot;
</del><span class="cx"> 
</span><span class="cx"> #ifndef NDEBUG
</span><span class="cx"> #include &lt;stdio.h&gt;
</span><span class="lines">@@ -220,14 +219,14 @@
</span><span class="cx"> 
</span><span class="cx"> void JIT::emitSlow_op_negate(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="cx"> {
</span><del>-    unsigned result = currentInstruction[1].u.operand;
</del><ins>+    unsigned dst = currentInstruction[1].u.operand;
</ins><span class="cx"> 
</span><span class="cx">     linkSlowCase(iter); // 0x7fffffff check
</span><span class="cx">     linkSlowCase(iter); // double check
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_negate);
-    slowPathCall.call();
-    emitGetVirtualRegister(result, regT0);
</del><ins>+    JITStubCall stubCall(this, cti_op_negate);
+    stubCall.addArgument(regT0);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_lshift(Instruction* currentInstruction)
</span><span class="lines">@@ -250,12 +249,17 @@
</span><span class="cx"> void JIT::emitSlow_op_lshift(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="cx"> {
</span><span class="cx">     unsigned result = currentInstruction[1].u.operand;
</span><ins>+    unsigned op1 = currentInstruction[2].u.operand;
+    unsigned op2 = currentInstruction[3].u.operand;
</ins><span class="cx"> 
</span><ins>+    UNUSED_PARAM(op1);
+    UNUSED_PARAM(op2);
</ins><span class="cx">     linkSlowCase(iter);
</span><span class="cx">     linkSlowCase(iter);
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_lshift);
-    slowPathCall.call();
-    emitGetVirtualRegister(result, regT0);
</del><ins>+    JITStubCall stubCall(this, cti_op_lshift);
+    stubCall.addArgument(regT0);
+    stubCall.addArgument(regT2);
+    stubCall.call(result);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_rshift(Instruction* currentInstruction)
</span><span class="lines">@@ -299,25 +303,31 @@
</span><span class="cx">     unsigned op1 = currentInstruction[2].u.operand;
</span><span class="cx">     unsigned op2 = currentInstruction[3].u.operand;
</span><span class="cx"> 
</span><del>-    UNUSED_PARAM(op1);
</del><ins>+    JITStubCall stubCall(this, cti_op_rshift);
</ins><span class="cx"> 
</span><del>-    if (isOperandConstantImmediateInt(op2))
</del><ins>+    if (isOperandConstantImmediateInt(op2)) {
</ins><span class="cx">         linkSlowCase(iter);
</span><del>-
-    else {
</del><ins>+        stubCall.addArgument(regT0);
+        stubCall.addArgument(op2, regT2);
+    } else {
</ins><span class="cx">         if (supportsFloatingPointTruncate()) {
</span><span class="cx">             linkSlowCase(iter);
</span><span class="cx">             linkSlowCase(iter);
</span><span class="cx">             linkSlowCase(iter);
</span><ins>+            // We're reloading op1 to regT0 as we can no longer guarantee that
+            // we have not munged the operand.  It may have already been shifted
+            // correctly, but it still will not have been tagged.
+            stubCall.addArgument(op1, regT0);
+            stubCall.addArgument(regT2);
</ins><span class="cx">         } else {
</span><span class="cx">             linkSlowCase(iter);
</span><span class="cx">             linkSlowCase(iter);
</span><ins>+            stubCall.addArgument(regT0);
+            stubCall.addArgument(regT2);
</ins><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_rshift);
-    slowPathCall.call();
-    emitGetVirtualRegister(result, regT0);
</del><ins>+    stubCall.call(result);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_urshift(Instruction* currentInstruction)
</span><span class="lines">@@ -408,9 +418,10 @@
</span><span class="cx">         linkSlowCase(iter); // Can't represent unsigned result as an immediate
</span><span class="cx">     }
</span><span class="cx">     
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_urshift);
-    slowPathCall.call();
-    emitGetVirtualRegister(dst, regT0);
</del><ins>+    JITStubCall stubCall(this, cti_op_urshift);
+    stubCall.addArgument(op1, regT0);
+    stubCall.addArgument(op2, regT1);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_compareAndJump(OpcodeID, unsigned op1, unsigned op2, unsigned target, RelationalCondition condition)
</span><span class="lines">@@ -596,12 +607,26 @@
</span><span class="cx"> void JIT::emitSlow_op_bitand(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="cx"> {
</span><span class="cx">     unsigned result = currentInstruction[1].u.operand;
</span><ins>+    unsigned op1 = currentInstruction[2].u.operand;
+    unsigned op2 = currentInstruction[3].u.operand;
</ins><span class="cx"> 
</span><span class="cx">     linkSlowCase(iter);
</span><del>-
-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_bitand);
-    slowPathCall.call();
-    emitGetVirtualRegister(result, regT0);
</del><ins>+    if (isOperandConstantImmediateInt(op1)) {
+        JITStubCall stubCall(this, cti_op_bitand);
+        stubCall.addArgument(op1, regT2);
+        stubCall.addArgument(regT0);
+        stubCall.call(result);
+    } else if (isOperandConstantImmediateInt(op2)) {
+        JITStubCall stubCall(this, cti_op_bitand);
+        stubCall.addArgument(regT0);
+        stubCall.addArgument(op2, regT2);
+        stubCall.call(result);
+    } else {
+        JITStubCall stubCall(this, cti_op_bitand);
+        stubCall.addArgument(op1, regT2);
+        stubCall.addArgument(regT1);
+        stubCall.call(result);
+    }
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_inc(Instruction* currentInstruction)
</span><span class="lines">@@ -619,11 +644,13 @@
</span><span class="cx"> {
</span><span class="cx">     unsigned srcDst = currentInstruction[1].u.operand;
</span><span class="cx"> 
</span><ins>+    Jump notImm = getSlowCase(iter);
</ins><span class="cx">     linkSlowCase(iter);
</span><del>-    linkSlowCase(iter);
-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_inc);
-    slowPathCall.call();
</del><span class="cx">     emitGetVirtualRegister(srcDst, regT0);
</span><ins>+    notImm.link(this);
+    JITStubCall stubCall(this, cti_op_inc);
+    stubCall.addArgument(regT0);
+    stubCall.call(srcDst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_dec(Instruction* currentInstruction)
</span><span class="lines">@@ -641,11 +668,13 @@
</span><span class="cx"> {
</span><span class="cx">     unsigned srcDst = currentInstruction[1].u.operand;
</span><span class="cx"> 
</span><ins>+    Jump notImm = getSlowCase(iter);
</ins><span class="cx">     linkSlowCase(iter);
</span><del>-    linkSlowCase(iter);
-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_dec);
-    slowPathCall.call();
</del><span class="cx">     emitGetVirtualRegister(srcDst, regT0);
</span><ins>+    notImm.link(this);
+    JITStubCall stubCall(this, cti_op_dec);
+    stubCall.addArgument(regT0);
+    stubCall.call(srcDst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> /* ------------------------------ BEGIN: OP_MOD ------------------------------ */
</span><span class="lines">@@ -690,9 +719,10 @@
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx">     linkSlowCase(iter);
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_mod);
-    slowPathCall.call();
-    emitGetVirtualRegister(result, regT0);
</del><ins>+    JITStubCall stubCall(this, cti_op_mod);
+    stubCall.addArgument(regT3);
+    stubCall.addArgument(regT2);
+    stubCall.call(result);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> #else // CPU(X86) || CPU(X86_64)
</span><span class="lines">@@ -703,12 +733,10 @@
</span><span class="cx">     unsigned op1 = currentInstruction[2].u.operand;
</span><span class="cx">     unsigned op2 = currentInstruction[3].u.operand;
</span><span class="cx"> 
</span><del>-    UNUSED_PARAM(op1);
-    UNUSED_PARAM(op2);
-
-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_mod);
-    slowPathCall.call();
-    emitGetVirtualRegister(result, regT0);
</del><ins>+    JITStubCall stubCall(this, cti_op_mod);
+    stubCall.addArgument(op1, regT2);
+    stubCall.addArgument(op2, regT2);
+    stubCall.call(result);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emitSlow_op_mod(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="lines">@@ -768,7 +796,7 @@
</span><span class="cx">     emitFastArithIntToImmNoCheck(regT0, regT0);
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-void JIT::compileBinaryArithOpSlowCase(Instruction* currentInstruction, OpcodeID opcodeID, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter, unsigned result, unsigned op1, unsigned op2, OperandTypes types, bool op1HasImmediateIntFastCase, bool op2HasImmediateIntFastCase)
</del><ins>+void JIT::compileBinaryArithOpSlowCase(OpcodeID opcodeID, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter, unsigned result, unsigned op1, unsigned op2, OperandTypes types, bool op1HasImmediateIntFastCase, bool op2HasImmediateIntFastCase)
</ins><span class="cx"> {
</span><span class="cx">     // We assume that subtracting TagTypeNumber is equivalent to adding DoubleEncodeOffset.
</span><span class="cx">     COMPILE_ASSERT(((TagTypeNumber + DoubleEncodeOffset) == 0), TagTypeNumber_PLUS_DoubleEncodeOffset_EQUALS_0);
</span><span class="lines">@@ -787,12 +815,17 @@
</span><span class="cx">     linkSlowCase(iter); // Integer overflow case - we could handle this in JIT code, but this is likely rare.
</span><span class="cx">     if (opcodeID == op_mul &amp;&amp; !op1HasImmediateIntFastCase &amp;&amp; !op2HasImmediateIntFastCase) // op_mul has an extra slow case to handle 0 * negative number.
</span><span class="cx">         linkSlowCase(iter);
</span><ins>+    emitGetVirtualRegister(op1, regT0);
</ins><span class="cx"> 
</span><span class="cx">     Label stubFunctionCall(this);
</span><del>-
-    JITSlowPathCall slowPathCall(this, currentInstruction, opcodeID == op_add ? slow_path_add : opcodeID == op_sub ? slow_path_sub : slow_path_mul);
-    slowPathCall.call();
-    emitGetVirtualRegister(result, regT0);
</del><ins>+    JITStubCall stubCall(this, opcodeID == op_add ? cti_op_add : opcodeID == op_sub ? cti_op_sub : cti_op_mul);
+    if (op1HasImmediateIntFastCase || op2HasImmediateIntFastCase) {
+        emitGetVirtualRegister(op1, regT0);
+        emitGetVirtualRegister(op2, regT1);
+    }
+    stubCall.addArgument(regT0);
+    stubCall.addArgument(regT1);
+    stubCall.call(result);
</ins><span class="cx">     Jump end = jump();
</span><span class="cx"> 
</span><span class="cx">     if (op1HasImmediateIntFastCase) {
</span><span class="lines">@@ -861,8 +894,10 @@
</span><span class="cx"> 
</span><span class="cx">     if (!types.first().mightBeNumber() || !types.second().mightBeNumber()) {
</span><span class="cx">         addSlowCase();
</span><del>-        JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_add);
-        slowPathCall.call();
</del><ins>+        JITStubCall stubCall(this, cti_op_add);
+        stubCall.addArgument(op1, regT2);
+        stubCall.addArgument(op2, regT2);
+        stubCall.call(result);
</ins><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -896,7 +931,7 @@
</span><span class="cx"> 
</span><span class="cx">     bool op1HasImmediateIntFastCase = isOperandConstantImmediateInt(op1);
</span><span class="cx">     bool op2HasImmediateIntFastCase = !op1HasImmediateIntFastCase &amp;&amp; isOperandConstantImmediateInt(op2);
</span><del>-    compileBinaryArithOpSlowCase(currentInstruction, op_add, iter, result, op1, op2, types, op1HasImmediateIntFastCase, op2HasImmediateIntFastCase);
</del><ins>+    compileBinaryArithOpSlowCase(op_add, iter, result, op1, op2, types, op1HasImmediateIntFastCase, op2HasImmediateIntFastCase);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_mul(Instruction* currentInstruction)
</span><span class="lines">@@ -941,7 +976,7 @@
</span><span class="cx"> 
</span><span class="cx">     bool op1HasImmediateIntFastCase = isOperandConstantImmediateInt(op1) &amp;&amp; getConstantOperandImmediateInt(op1) &gt; 0;
</span><span class="cx">     bool op2HasImmediateIntFastCase = !op1HasImmediateIntFastCase &amp;&amp; isOperandConstantImmediateInt(op2) &amp;&amp; getConstantOperandImmediateInt(op2) &gt; 0;
</span><del>-    compileBinaryArithOpSlowCase(currentInstruction, op_mul, iter, result, op1, op2, types, op1HasImmediateIntFastCase, op2HasImmediateIntFastCase);
</del><ins>+    compileBinaryArithOpSlowCase(op_mul, iter, result, op1, op2, types, op1HasImmediateIntFastCase, op2HasImmediateIntFastCase);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_div(Instruction* currentInstruction)
</span><span class="lines">@@ -1047,9 +1082,10 @@
</span><span class="cx">             linkSlowCase(iter);
</span><span class="cx">     }
</span><span class="cx">     // There is an extra slow case for (op1 * -N) or (-N * op2), to check for 0 since this should produce a result of -0.
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_div);
-    slowPathCall.call();
-    emitGetVirtualRegister(result, regT0);
</del><ins>+    JITStubCall stubCall(this, cti_op_div);
+    stubCall.addArgument(op1, regT2);
+    stubCall.addArgument(op2, regT2);
+    stubCall.call(result);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_sub(Instruction* currentInstruction)
</span><span class="lines">@@ -1070,7 +1106,7 @@
</span><span class="cx">     unsigned op2 = currentInstruction[3].u.operand;
</span><span class="cx">     OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
</span><span class="cx"> 
</span><del>-    compileBinaryArithOpSlowCase(currentInstruction, op_sub, iter, result, op1, op2, types, false, false);
</del><ins>+    compileBinaryArithOpSlowCase(op_sub, iter, result, op1, op2, types, false, false);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> /* ------------------------------ END: OP_ADD, OP_SUB, OP_MUL ------------------------------ */
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJITArithmetic32_64cpp"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JITArithmetic32_64.cpp (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JITArithmetic32_64.cpp        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JITArithmetic32_64.cpp        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -39,7 +39,6 @@
</span><span class="cx"> #include &quot;Operations.h&quot;
</span><span class="cx"> #include &quot;ResultType.h&quot;
</span><span class="cx"> #include &quot;SamplingTool.h&quot;
</span><del>-#include &quot;SlowPathCall.h&quot;
</del><span class="cx"> 
</span><span class="cx"> #ifndef NDEBUG
</span><span class="cx"> #include &lt;stdio.h&gt;
</span><span class="lines">@@ -81,9 +80,9 @@
</span><span class="cx">     linkSlowCase(iter); // 0x7fffffff check
</span><span class="cx">     linkSlowCase(iter); // double check
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_negate);
-    slowPathCall.call();
-    emitLoad(dst, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_negate);
+    stubCall.addArgument(regT1, regT0);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_compareAndJump(OpcodeID opcode, unsigned op1, unsigned op2, unsigned target, RelationalCondition condition)
</span><span class="lines">@@ -199,9 +198,10 @@
</span><span class="cx">         linkSlowCase(iter); // int32 check
</span><span class="cx">     linkSlowCase(iter); // int32 check
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_lshift);
-    slowPathCall.call();
-    emitLoad(dst, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_lshift);
+    stubCall.addArgument(op1);
+    stubCall.addArgument(op2);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> // RightShift (&gt;&gt;) and UnsignedRightShift (&gt;&gt;&gt;) helper
</span><span class="lines">@@ -296,9 +296,10 @@
</span><span class="cx">             linkSlowCase(iter); // Can't represent unsigned result as an immediate
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, isUnsigned ? slow_path_urshift : slow_path_rshift);
-    slowPathCall.call();
-    emitLoad(dst, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, isUnsigned ? cti_op_urshift : cti_op_rshift);
+    stubCall.addArgument(op1);
+    stubCall.addArgument(op2);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> // RightShift (&gt;&gt;)
</span><span class="lines">@@ -360,9 +361,10 @@
</span><span class="cx">         linkSlowCase(iter); // int32 check
</span><span class="cx">     linkSlowCase(iter); // int32 check
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_bitand);
-    slowPathCall.call();
-    emitLoad(dst, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_bitand);
+    stubCall.addArgument(op1);
+    stubCall.addArgument(op2);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> // BitOr (|)
</span><span class="lines">@@ -400,9 +402,10 @@
</span><span class="cx">         linkSlowCase(iter); // int32 check
</span><span class="cx">     linkSlowCase(iter); // int32 check
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_bitor);
-    slowPathCall.call();
-    emitLoad(dst, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_bitor);
+    stubCall.addArgument(op1);
+    stubCall.addArgument(op2);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> // BitXor (^)
</span><span class="lines">@@ -440,9 +443,10 @@
</span><span class="cx">         linkSlowCase(iter); // int32 check
</span><span class="cx">     linkSlowCase(iter); // int32 check
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_bitxor);
-    slowPathCall.call();
-    emitLoad(dst, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_bitxor);
+    stubCall.addArgument(op1);
+    stubCall.addArgument(op2);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_inc(Instruction* currentInstruction)
</span><span class="lines">@@ -463,9 +467,9 @@
</span><span class="cx">     linkSlowCase(iter); // int32 check
</span><span class="cx">     linkSlowCase(iter); // overflow check
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_inc);
-    slowPathCall.call();
-    emitLoad(srcDst, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_inc);
+    stubCall.addArgument(srcDst);
+    stubCall.call(srcDst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_dec(Instruction* currentInstruction)
</span><span class="lines">@@ -486,9 +490,9 @@
</span><span class="cx">     linkSlowCase(iter); // int32 check
</span><span class="cx">     linkSlowCase(iter); // overflow check
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_dec);
-    slowPathCall.call();
-    emitLoad(srcDst, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_dec);
+    stubCall.addArgument(srcDst);
+    stubCall.call(srcDst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> // Addition (+)
</span><span class="lines">@@ -502,9 +506,10 @@
</span><span class="cx"> 
</span><span class="cx">     if (!types.first().mightBeNumber() || !types.second().mightBeNumber()) {
</span><span class="cx">         addSlowCase();
</span><del>-        JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_add);
-        slowPathCall.call();
-        emitLoad(dst, regT1, regT0, callFrameRegister);
</del><ins>+        JITStubCall stubCall(this, cti_op_add);
+        stubCall.addArgument(op1);
+        stubCall.addArgument(op2);
+        stubCall.call(dst);
</ins><span class="cx">         return;
</span><span class="cx">     }
</span><span class="cx"> 
</span><span class="lines">@@ -606,9 +611,10 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_add);
-    slowPathCall.call();
-    emitLoad(dst, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_add);
+    stubCall.addArgument(op1);
+    stubCall.addArgument(op2);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> // Subtraction (-)
</span><span class="lines">@@ -683,6 +689,7 @@
</span><span class="cx"> void JIT::emitSlow_op_sub(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="cx"> {
</span><span class="cx">     unsigned dst = currentInstruction[1].u.operand;
</span><ins>+    unsigned op1 = currentInstruction[2].u.operand;
</ins><span class="cx">     unsigned op2 = currentInstruction[3].u.operand;
</span><span class="cx">     OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
</span><span class="cx"> 
</span><span class="lines">@@ -708,9 +715,10 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_sub);
-    slowPathCall.call();
-    emitLoad(dst, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_sub);
+    stubCall.addArgument(op1);
+    stubCall.addArgument(op2);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emitBinaryDoubleOp(OpcodeID opcodeID, unsigned dst, unsigned op1, unsigned op2, OperandTypes types, JumpList&amp; notInt32Op1, JumpList&amp; notInt32Op2, bool op1IsInRegisters, bool op2IsInRegisters)
</span><span class="lines">@@ -1014,9 +1022,11 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_mul);
-    slowPathCall.call();
-    emitLoad(dst, regT1, regT0, callFrameRegister);
</del><ins>+    Label jitStubCall(this);
+    JITStubCall stubCall(this, cti_op_mul);
+    stubCall.addArgument(op1);
+    stubCall.addArgument(op2);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> // Division (/)
</span><span class="lines">@@ -1087,7 +1097,8 @@
</span><span class="cx"> void JIT::emitSlow_op_div(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="cx"> {
</span><span class="cx">     unsigned dst = currentInstruction[1].u.operand;
</span><del>-
</del><ins>+    unsigned op1 = currentInstruction[2].u.operand;
+    unsigned op2 = currentInstruction[3].u.operand;
</ins><span class="cx">     OperandTypes types = OperandTypes::fromInt(currentInstruction[4].u.operand);
</span><span class="cx"> 
</span><span class="cx">     if (!supportsFloatingPoint())
</span><span class="lines">@@ -1102,9 +1113,10 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_div);
-    slowPathCall.call();
-    emitLoad(dst, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_div);
+    stubCall.addArgument(op1);
+    stubCall.addArgument(op2);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> // Mod (%)
</span><span class="lines">@@ -1140,9 +1152,10 @@
</span><span class="cx">     numeratorPositive.link(this);
</span><span class="cx">     emitStoreInt32(dst, regT1, (op1 == dst || op2 == dst));
</span><span class="cx"> #else
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_mod);
-    slowPathCall.call();
-    emitLoad(result, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_mod);
+    stubCall.addArgument(op1);
+    stubCall.addArgument(op2);
+    stubCall.call(dst);
</ins><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx"> 
</span><span class="lines">@@ -1150,14 +1163,17 @@
</span><span class="cx"> {
</span><span class="cx"> #if CPU(X86) || CPU(X86_64)
</span><span class="cx">     unsigned result = currentInstruction[1].u.operand;
</span><ins>+    unsigned op1 = currentInstruction[2].u.operand;
+    unsigned op2 = currentInstruction[3].u.operand;
</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">     linkSlowCase(iter);
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_mod);
-    slowPathCall.call();
-    emitLoad(result, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_mod);
+    stubCall.addArgument(op1);
+    stubCall.addArgument(op2);
+    stubCall.call(result);
</ins><span class="cx"> #else
</span><span class="cx">     UNUSED_PARAM(currentInstruction);
</span><span class="cx">     UNUSED_PARAM(iter);
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJITExceptionscpp"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JITExceptions.cpp (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JITExceptions.cpp        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JITExceptions.cpp        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -37,17 +37,6 @@
</span><span class="cx"> 
</span><span class="cx"> namespace JSC {
</span><span class="cx"> 
</span><del>-static unsigned getExceptionLocation(VM* vm, CallFrame* callFrame)
-{
-    UNUSED_PARAM(vm);
-    ASSERT(!callFrame-&gt;hasHostCallFrameFlag());
-
-    if (callFrame-&gt;hasLocationAsCodeOriginIndex())
-        return callFrame-&gt;bytecodeOffsetFromCodeOriginIndex();
-
-    return callFrame-&gt;locationAsBytecodeOffset();
-}
-
</del><span class="cx"> ExceptionHandler genericThrow(VM* vm, ExecState* callFrame, JSValue exceptionValue, unsigned vPCIndex)
</span><span class="cx"> {
</span><span class="cx">     RELEASE_ASSERT(exceptionValue);
</span><span class="lines">@@ -69,17 +58,10 @@
</span><span class="cx">     vm-&gt;targetInterpreterPCForThrow = catchPCForInterpreter;
</span><span class="cx">     
</span><span class="cx">     RELEASE_ASSERT(catchRoutine);
</span><del>-    ExceptionHandler exceptionHandler = { callFrame, catchRoutine};
</del><ins>+    ExceptionHandler exceptionHandler = { catchRoutine, callFrame };
</ins><span class="cx">     return exceptionHandler;
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-ExceptionHandler jitThrowNew(VM* vm, ExecState* callFrame, JSValue exceptionValue)
-{
-    unsigned bytecodeOffset = getExceptionLocation(vm, callFrame);
-    
-    return genericThrow(vm, callFrame, exceptionValue, bytecodeOffset);
-}
-
</del><span class="cx"> ExceptionHandler jitThrow(VM* vm, ExecState* callFrame, JSValue exceptionValue, ReturnAddressPtr faultLocation)
</span><span class="cx"> {
</span><span class="cx">     return genericThrow(vm, callFrame, exceptionValue, callFrame-&gt;codeBlock()-&gt;bytecodeOffset(callFrame, faultLocation));
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJITExceptionsh"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JITExceptions.h (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JITExceptions.h        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JITExceptions.h        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -40,13 +40,12 @@
</span><span class="cx"> // for the throwing and handling exceptions.
</span><span class="cx"> 
</span><span class="cx"> struct ExceptionHandler {
</span><del>-    ExecState* callFrame;
</del><span class="cx">     void* catchRoutine;
</span><ins>+    ExecState* callFrame;
</ins><span class="cx"> };
</span><span class="cx"> 
</span><span class="cx"> ExceptionHandler genericThrow(VM*, ExecState*, JSValue exceptionValue, unsigned vPCIndex);
</span><span class="cx"> 
</span><del>-ExceptionHandler jitThrowNew(VM*, ExecState*, JSValue exceptionValue);
</del><span class="cx"> ExceptionHandler jitThrow(VM*, ExecState*, JSValue exceptionValue, ReturnAddressPtr faultLocation);
</span><span class="cx"> 
</span><span class="cx"> } // namespace JSC
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJITOpcodescpp"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JITOpcodes.cpp (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JITOpcodes.cpp        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JITOpcodes.cpp        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -38,7 +38,6 @@
</span><span class="cx"> #include &quot;JSFunction.h&quot;
</span><span class="cx"> #include &quot;JSPropertyNameIterator.h&quot;
</span><span class="cx"> #include &quot;LinkBuffer.h&quot;
</span><del>-#include &quot;SlowPathCall.h&quot;
</del><span class="cx"> 
</span><span class="cx"> namespace JSC {
</span><span class="cx"> 
</span><span class="lines">@@ -341,9 +340,10 @@
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_strcat(Instruction* currentInstruction)
</span><span class="cx"> {
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_strcat);
-    slowPathCall.call();
-    emitGetVirtualRegister(currentInstruction[1].u.operand, regT0);
</del><ins>+    JITStubCall stubCall(this, cti_op_strcat);
+    stubCall.addArgument(TrustedImm32(currentInstruction[2].u.operand));
+    stubCall.addArgument(TrustedImm32(currentInstruction[3].u.operand));
+    stubCall.call(currentInstruction[1].u.operand);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_ensure_property_exists(Instruction* currentInstruction)
</span><span class="lines">@@ -918,9 +918,9 @@
</span><span class="cx">     linkSlowCase(iter); // doesn't have an allocation profile
</span><span class="cx">     linkSlowCase(iter); // allocation failed
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_create_this);
-    slowPathCall.call();
-    emitGetVirtualRegister(currentInstruction[1].u.operand, regT0);
</del><ins>+    JITStubCall stubCall(this, cti_op_create_this);
+    stubCall.addArgument(TrustedImm32(currentInstruction[3].u.operand));
+    stubCall.call(currentInstruction[1].u.operand);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_profile_will_call(Instruction* currentInstruction)
</span><span class="lines">@@ -944,28 +944,27 @@
</span><span class="cx"> {
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx">     linkSlowCase(iter);
</span><del>-
-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_to_this);
-    slowPathCall.call();
-    emitGetVirtualRegister(currentInstruction[1].u.operand, regT0);
</del><ins>+    JITStubCall stubCall(this, cti_op_to_this);
+    stubCall.addArgument(regT1);
+    stubCall.call(currentInstruction[1].u.operand);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emitSlow_op_to_primitive(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="cx"> {
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_to_primitive);
-    slowPathCall.call();
-    emitGetVirtualRegister(currentInstruction[1].u.operand, regT0);
</del><ins>+    JITStubCall stubCall(this, cti_op_to_primitive);
+    stubCall.addArgument(regT0);
+    stubCall.call(currentInstruction[1].u.operand);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emitSlow_op_not(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="cx"> {
</span><span class="cx">     linkSlowCase(iter);
</span><del>-    
-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_not);
-    slowPathCall.call();
-    emitGetVirtualRegister(currentInstruction[1].u.operand, regT0);
</del><ins>+    xor64(TrustedImm32(static_cast&lt;int32_t&gt;(ValueFalse)), regT0);
+    JITStubCall stubCall(this, cti_op_not);
+    stubCall.addArgument(regT0);
+    stubCall.call(currentInstruction[1].u.operand);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emitSlow_op_jfalse(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="lines">@@ -989,15 +988,19 @@
</span><span class="cx"> void JIT::emitSlow_op_bitxor(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="cx"> {
</span><span class="cx">     linkSlowCase(iter);
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_bitxor);
-    slowPathCall.call();
</del><ins>+    JITStubCall stubCall(this, cti_op_bitxor);
+    stubCall.addArgument(regT0);
+    stubCall.addArgument(regT1);
+    stubCall.call(currentInstruction[1].u.operand);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emitSlow_op_bitor(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="cx"> {
</span><span class="cx">     linkSlowCase(iter);
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_bitor);
-    slowPathCall.call();
</del><ins>+    JITStubCall stubCall(this, cti_op_bitor);
+    stubCall.addArgument(regT0);
+    stubCall.addArgument(regT1);
+    stubCall.call(currentInstruction[1].u.operand);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emitSlow_op_eq(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="lines">@@ -1028,9 +1031,10 @@
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx">     linkSlowCase(iter);
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_stricteq);
-    slowPathCall.call();
-    emitGetVirtualRegister(currentInstruction[1].u.operand, regT0);
</del><ins>+    JITStubCall stubCall(this, cti_op_stricteq);
+    stubCall.addArgument(regT0);
+    stubCall.addArgument(regT1);
+    stubCall.call(currentInstruction[1].u.operand);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emitSlow_op_nstricteq(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="lines">@@ -1038,9 +1042,10 @@
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx">     linkSlowCase(iter);
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_nstricteq);
-    slowPathCall.call();
-    emitGetVirtualRegister(currentInstruction[1].u.operand, regT0);
</del><ins>+    JITStubCall stubCall(this, cti_op_nstricteq);
+    stubCall.addArgument(regT0);
+    stubCall.addArgument(regT1);
+    stubCall.call(currentInstruction[1].u.operand);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emitSlow_op_check_has_instance(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="lines">@@ -1078,9 +1083,9 @@
</span><span class="cx"> {
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_to_number);
-    slowPathCall.call();
-    emitGetVirtualRegister(currentInstruction[1].u.operand, regT0);
</del><ins>+    JITStubCall stubCall(this, cti_op_to_number);
+    stubCall.addArgument(regT0);
+    stubCall.call(currentInstruction[1].u.operand);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_get_arguments_length(Instruction* currentInstruction)
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJITOpcodes32_64cpp"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -38,7 +38,6 @@
</span><span class="cx"> #include &quot;JSPropertyNameIterator.h&quot;
</span><span class="cx"> #include &quot;JSVariableObject.h&quot;
</span><span class="cx"> #include &quot;LinkBuffer.h&quot;
</span><del>-#include &quot;SlowPathCall.h&quot;
</del><span class="cx"> 
</span><span class="cx"> namespace JSC {
</span><span class="cx"> 
</span><span class="lines">@@ -168,10 +167,14 @@
</span><span class="cx"> 
</span><span class="cx">     move(TrustedImmPtr(&amp;vm-&gt;exceptionLocation), regT2);
</span><span class="cx">     storePtr(regT1, regT2);
</span><ins>+    poke(callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
+    
</ins><span class="cx">     storePtr(callFrameRegister, &amp;m_vm-&gt;topCallFrame);
</span><ins>+    // Set the return address.
+    move(TrustedImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()), regT1);
+    restoreReturnAddressBeforeReturn(regT1);
</ins><span class="cx"> 
</span><del>-    move(TrustedImmPtr(FunctionPtr(ctiVMThrowTrampolineSlowpath).value()), regT1);
-    jump(regT1);
</del><ins>+    ret();
</ins><span class="cx"> 
</span><span class="cx">     // All trampolines constructed! copy the code, link up calls, and set the pointers on the Machine object.
</span><span class="cx">     LinkBuffer patchBuffer(*m_vm, this, GLOBAL_THUNK_ID);
</span><span class="lines">@@ -430,15 +433,17 @@
</span><span class="cx"> 
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_to_primitive);
-    slowPathCall.call();
-    emitLoad(dst, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_to_primitive);
+    stubCall.addArgument(regT1, regT0);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_strcat(Instruction* currentInstruction)
</span><span class="cx"> {
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_strcat);
-    slowPathCall.call();
</del><ins>+    JITStubCall stubCall(this, cti_op_strcat);
+    stubCall.addArgument(TrustedImm32(currentInstruction[2].u.operand));
+    stubCall.addArgument(TrustedImm32(currentInstruction[3].u.operand));
+    stubCall.call(currentInstruction[1].u.operand);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_ensure_property_exists(Instruction* currentInstruction)
</span><span class="lines">@@ -466,12 +471,13 @@
</span><span class="cx"> void JIT::emitSlow_op_not(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="cx"> {
</span><span class="cx">     unsigned dst = currentInstruction[1].u.operand;
</span><ins>+    unsigned src = currentInstruction[2].u.operand;
</ins><span class="cx"> 
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_not);
-    slowPathCall.call();
-    emitLoad(dst, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_not);
+    stubCall.addArgument(src);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_jfalse(Instruction* currentInstruction)
</span><span class="lines">@@ -744,14 +750,17 @@
</span><span class="cx"> void JIT::emitSlow_op_stricteq(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="cx"> {
</span><span class="cx">     unsigned dst = currentInstruction[1].u.operand;
</span><ins>+    unsigned src1 = currentInstruction[2].u.operand;
+    unsigned src2 = currentInstruction[3].u.operand;
</ins><span class="cx"> 
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_stricteq);
-    slowPathCall.call();
-    emitLoad(dst, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_stricteq);
+    stubCall.addArgument(src1);
+    stubCall.addArgument(src2);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_nstricteq(Instruction* currentInstruction)
</span><span class="lines">@@ -762,14 +771,17 @@
</span><span class="cx"> void JIT::emitSlow_op_nstricteq(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="cx"> {
</span><span class="cx">     unsigned dst = currentInstruction[1].u.operand;
</span><ins>+    unsigned src1 = currentInstruction[2].u.operand;
+    unsigned src2 = currentInstruction[3].u.operand;
</ins><span class="cx"> 
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_nstricteq);
-    slowPathCall.call();
-    emitLoad(dst, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_nstricteq);
+    stubCall.addArgument(src1);
+    stubCall.addArgument(src2);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_eq_null(Instruction* currentInstruction)
</span><span class="lines">@@ -989,9 +1001,9 @@
</span><span class="cx"> 
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_to_number);
-    slowPathCall.call();
-    emitLoad(dst, regT1, regT0, callFrameRegister);
</del><ins>+    JITStubCall stubCall(this, cti_op_to_number);
+    stubCall.addArgument(regT1, regT0);
+    stubCall.call(dst);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_push_name_scope(Instruction* currentInstruction)
</span><span class="lines">@@ -1125,8 +1137,9 @@
</span><span class="cx"> 
</span><span class="cx">     Jump argsCreated = branch32(NotEqual, tagFor(dst), TrustedImm32(JSValue::EmptyValueTag));
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_create_arguments);
-    slowPathCall.call();
</del><ins>+    JITStubCall(this, cti_op_create_arguments).call();
+    emitStore(dst, regT1, regT0);
+    emitStore(unmodifiedArgumentsRegister(dst), regT1, regT0);
</ins><span class="cx"> 
</span><span class="cx">     argsCreated.link(this);
</span><span class="cx"> }
</span><span class="lines">@@ -1170,8 +1183,9 @@
</span><span class="cx">     linkSlowCase(iter); // doesn't have an allocation profile
</span><span class="cx">     linkSlowCase(iter); // allocation failed
</span><span class="cx"> 
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_create_this);
-    slowPathCall.call();
</del><ins>+    JITStubCall stubCall(this, cti_op_create_this);
+    stubCall.addArgument(TrustedImm32(currentInstruction[3].u.operand));
+    stubCall.call(currentInstruction[1].u.operand);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_to_this(Instruction* currentInstruction)
</span><span class="lines">@@ -1191,10 +1205,13 @@
</span><span class="cx"> 
</span><span class="cx"> void JIT::emitSlow_op_to_this(Instruction* currentInstruction, Vector&lt;SlowCaseEntry&gt;::iterator&amp; iter)
</span><span class="cx"> {
</span><ins>+    unsigned thisRegister = currentInstruction[1].u.operand;
+
</ins><span class="cx">     linkSlowCase(iter);
</span><span class="cx">     linkSlowCase(iter);
</span><del>-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_to_this);
-    slowPathCall.call();
</del><ins>+    JITStubCall stubCall(this, cti_op_to_this);
+    stubCall.addArgument(regT3, regT2);
+    stubCall.call(thisRegister);
</ins><span class="cx"> }
</span><span class="cx"> 
</span><span class="cx"> void JIT::emit_op_profile_will_call(Instruction* currentInstruction)
</span><span class="lines">@@ -1265,9 +1282,9 @@
</span><span class="cx"> 
</span><span class="cx">     linkSlowCase(iter);
</span><span class="cx">     linkSlowCase(iter);
</span><del>-
-    JITSlowPathCall slowPathCall(this, currentInstruction, slow_path_create_arguments);
-    slowPathCall.call();
</del><ins>+    JITStubCall(this, cti_op_create_arguments).call();
+    emitStore(arguments, regT1, regT0);
+    emitStore(unmodifiedArgumentsRegister(arguments), regT1, regT0);
</ins><span class="cx">     
</span><span class="cx">     skipArgumentsCreation.link(this);
</span><span class="cx">     JITStubCall stubCall(this, cti_op_get_by_val_generic);
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJITStubscpp"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubs.cpp (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubs.cpp        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubs.cpp        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -70,7 +70,6 @@
</span><span class="cx"> #include &quot;Register.h&quot;
</span><span class="cx"> #include &quot;RepatchBuffer.h&quot;
</span><span class="cx"> #include &quot;SamplingTool.h&quot;
</span><del>-#include &quot;SlowPathCall.h&quot;
</del><span class="cx"> #include &quot;Strong.h&quot;
</span><span class="cx"> #include &quot;StructureRareDataInlines.h&quot;
</span><span class="cx"> #include &lt;wtf/StdLibExtras.h&gt;
</span><span class="lines">@@ -380,6 +379,71 @@
</span><span class="cx"> #define DEFINE_STUB_FUNCTION(rtype, op) rtype JIT_STUB cti_##op(STUB_ARGS_DECLARATION)
</span><span class="cx"> #endif
</span><span class="cx"> 
</span><ins>+DEFINE_STUB_FUNCTION(EncodedJSValue, op_create_this)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+    CallFrame* callFrame = stackFrame.callFrame;
+    size_t inlineCapacity = stackFrame.args[0].int32();
+
+    JSFunction* constructor = jsCast&lt;JSFunction*&gt;(callFrame-&gt;callee());
+#if !ASSERT_DISABLED
+    ConstructData constructData;
+    ASSERT(constructor-&gt;methodTable()-&gt;getConstructData(constructor, constructData) == ConstructTypeJS);
+#endif
+
+    Structure* structure = constructor-&gt;allocationProfile(callFrame, inlineCapacity)-&gt;structure();
+    JSValue result = constructEmptyObject(callFrame, structure);
+
+    return JSValue::encode(result);
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_to_this)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue v1 = stackFrame.args[0].jsValue();
+    CallFrame* callFrame = stackFrame.callFrame;
+
+    JSValue result = v1.toThis(callFrame, callFrame-&gt;codeBlock()-&gt;isStrictMode() ? StrictMode : NotStrictMode);
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_add)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue v1 = stackFrame.args[0].jsValue();
+    JSValue v2 = stackFrame.args[1].jsValue();
+    CallFrame* callFrame = stackFrame.callFrame;
+
+    if (v1.isString() &amp;&amp; !v2.isObject()) {
+        JSValue result = jsString(callFrame, asString(v1), v2.toString(callFrame));
+        CHECK_FOR_EXCEPTION_AT_END();
+        return JSValue::encode(result);
+    }
+
+    if (v1.isNumber() &amp;&amp; v2.isNumber())
+        return JSValue::encode(jsNumber(v1.asNumber() + v2.asNumber()));
+
+    // All other cases are pretty uncommon
+    JSValue result = jsAddSlowCase(callFrame, v1, v2);
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_inc)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue v = stackFrame.args[0].jsValue();
+
+    CallFrame* callFrame = stackFrame.callFrame;
+    JSValue result = jsNumber(v.toNumber(callFrame) + 1);
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
</ins><span class="cx"> DEFINE_STUB_FUNCTION(void, handle_watchdog_timer)
</span><span class="cx"> {
</span><span class="cx">     STUB_INIT_STACK_FRAME(stackFrame);
</span><span class="lines">@@ -1085,6 +1149,22 @@
</span><span class="cx">     return JSValue::encode(result);
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+DEFINE_STUB_FUNCTION(EncodedJSValue, op_mul)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue src1 = stackFrame.args[0].jsValue();
+    JSValue src2 = stackFrame.args[1].jsValue();
+
+    if (src1.isNumber() &amp;&amp; src2.isNumber())
+        return JSValue::encode(jsNumber(src1.asNumber() * src2.asNumber()));
+
+    CallFrame* callFrame = stackFrame.callFrame;
+    JSValue result = jsNumber(src1.toNumber(callFrame) * src2.toNumber(callFrame));
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
</ins><span class="cx"> DEFINE_STUB_FUNCTION(JSObject*, op_new_func)
</span><span class="cx"> {
</span><span class="cx">     STUB_INIT_STACK_FRAME(stackFrame);
</span><span class="lines">@@ -1619,7 +1699,23 @@
</span><span class="cx">     CHECK_FOR_EXCEPTION_AT_END();
</span><span class="cx">     return JSValue::encode(result);
</span><span class="cx"> }
</span><ins>+    
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_sub)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
</ins><span class="cx"> 
</span><ins>+    JSValue src1 = stackFrame.args[0].jsValue();
+    JSValue src2 = stackFrame.args[1].jsValue();
+
+    if (src1.isNumber() &amp;&amp; src2.isNumber())
+        return JSValue::encode(jsNumber(src1.asNumber() - src2.asNumber()));
+
+    CallFrame* callFrame = stackFrame.callFrame;
+    JSValue result = jsNumber(src1.toNumber(callFrame) - src2.toNumber(callFrame));
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
</ins><span class="cx"> static void putByVal(CallFrame* callFrame, JSValue baseValue, JSValue subscript, JSValue value)
</span><span class="cx"> {
</span><span class="cx">     if (LIKELY(subscript.isUInt32())) {
</span><span class="lines">@@ -1708,6 +1804,46 @@
</span><span class="cx">     CHECK_FOR_EXCEPTION_AT_END();
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+DEFINE_STUB_FUNCTION(EncodedJSValue, op_less)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    CallFrame* callFrame = stackFrame.callFrame;
+    JSValue result = jsBoolean(jsLess&lt;true&gt;(callFrame, stackFrame.args[0].jsValue(), stackFrame.args[1].jsValue()));
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_lesseq)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    CallFrame* callFrame = stackFrame.callFrame;
+    JSValue result = jsBoolean(jsLessEq&lt;true&gt;(callFrame, stackFrame.args[0].jsValue(), stackFrame.args[1].jsValue()));
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_greater)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    CallFrame* callFrame = stackFrame.callFrame;
+    JSValue result = jsBoolean(jsLess&lt;false&gt;(callFrame, stackFrame.args[1].jsValue(), stackFrame.args[0].jsValue()));
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_greatereq)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    CallFrame* callFrame = stackFrame.callFrame;
+    JSValue result = jsBoolean(jsLessEq&lt;false&gt;(callFrame, stackFrame.args[1].jsValue(), stackFrame.args[0].jsValue()));
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
</ins><span class="cx"> DEFINE_STUB_FUNCTION(void*, op_load_varargs)
</span><span class="cx"> {
</span><span class="cx">     STUB_INIT_STACK_FRAME(stackFrame);
</span><span class="lines">@@ -1724,6 +1860,21 @@
</span><span class="cx">     return newCallFrame;
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+DEFINE_STUB_FUNCTION(EncodedJSValue, op_negate)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue src = stackFrame.args[0].jsValue();
+
+    if (src.isNumber())
+        return JSValue::encode(jsNumber(-src.asNumber()));
+
+    CallFrame* callFrame = stackFrame.callFrame;
+    JSValue result = jsNumber(-src.toNumber(callFrame));
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
</ins><span class="cx"> DEFINE_STUB_FUNCTION(EncodedJSValue, op_resolve_base)
</span><span class="cx"> {
</span><span class="cx">     STUB_INIT_STACK_FRAME(stackFrame);
</span><span class="lines">@@ -1775,6 +1926,34 @@
</span><span class="cx">     return JSValue::encode(base);
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+DEFINE_STUB_FUNCTION(EncodedJSValue, op_div)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue src1 = stackFrame.args[0].jsValue();
+    JSValue src2 = stackFrame.args[1].jsValue();
+
+    if (src1.isNumber() &amp;&amp; src2.isNumber())
+        return JSValue::encode(jsNumber(src1.asNumber() / src2.asNumber()));
+
+    CallFrame* callFrame = stackFrame.callFrame;
+    JSValue result = jsNumber(src1.toNumber(callFrame) / src2.toNumber(callFrame));
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_dec)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue v = stackFrame.args[0].jsValue();
+
+    CallFrame* callFrame = stackFrame.callFrame;
+    JSValue result = jsNumber(v.toNumber(callFrame) - 1);
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
</ins><span class="cx"> DEFINE_STUB_FUNCTION(int, op_jless)
</span><span class="cx"> {
</span><span class="cx">     STUB_INIT_STACK_FRAME(stackFrame);
</span><span class="lines">@@ -1827,6 +2006,17 @@
</span><span class="cx">     return result;
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+DEFINE_STUB_FUNCTION(EncodedJSValue, op_not)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue src = stackFrame.args[0].jsValue();
+
+    JSValue result = jsBoolean(!src.toBoolean(stackFrame.callFrame));
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
</ins><span class="cx"> DEFINE_STUB_FUNCTION(int, op_jtrue)
</span><span class="cx"> {
</span><span class="cx">     STUB_INIT_STACK_FRAME(stackFrame);
</span><span class="lines">@@ -1954,6 +2144,47 @@
</span><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+DEFINE_STUB_FUNCTION(EncodedJSValue, op_lshift)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue val = stackFrame.args[0].jsValue();
+    JSValue shift = stackFrame.args[1].jsValue();
+
+    CallFrame* callFrame = stackFrame.callFrame;
+    JSValue result = jsNumber((val.toInt32(callFrame)) &lt;&lt; (shift.toUInt32(callFrame) &amp; 0x1f));
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_bitand)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue src1 = stackFrame.args[0].jsValue();
+    JSValue src2 = stackFrame.args[1].jsValue();
+
+    ASSERT(!src1.isInt32() || !src2.isInt32());
+    CallFrame* callFrame = stackFrame.callFrame;
+    JSValue result = jsNumber(src1.toInt32(callFrame) &amp; src2.toInt32(callFrame));
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_rshift)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue val = stackFrame.args[0].jsValue();
+    JSValue shift = stackFrame.args[1].jsValue();
+
+    CallFrame* callFrame = stackFrame.callFrame;
+    JSValue result = jsNumber((val.toInt32(callFrame)) &gt;&gt; (shift.toUInt32(callFrame) &amp; 0x1f));
+
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
</ins><span class="cx"> DEFINE_STUB_FUNCTION(EncodedJSValue, op_resolve_with_base)
</span><span class="cx"> {
</span><span class="cx">     STUB_INIT_STACK_FRAME(stackFrame);
</span><span class="lines">@@ -1998,6 +2229,47 @@
</span><span class="cx">     return func;
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+DEFINE_STUB_FUNCTION(EncodedJSValue, op_mod)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue dividendValue = stackFrame.args[0].jsValue();
+    JSValue divisorValue = stackFrame.args[1].jsValue();
+
+    CallFrame* callFrame = stackFrame.callFrame;
+    double d = dividendValue.toNumber(callFrame);
+    JSValue result = jsNumber(fmod(d, divisorValue.toNumber(callFrame)));
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_urshift)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue val = stackFrame.args[0].jsValue();
+    JSValue shift = stackFrame.args[1].jsValue();
+
+    CallFrame* callFrame = stackFrame.callFrame;
+    JSValue result = jsNumber((val.toUInt32(callFrame)) &gt;&gt; (shift.toUInt32(callFrame) &amp; 0x1f));
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_bitxor)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue src1 = stackFrame.args[0].jsValue();
+    JSValue src2 = stackFrame.args[1].jsValue();
+
+    CallFrame* callFrame = stackFrame.callFrame;
+
+    JSValue result = jsNumber(src1.toInt32(callFrame) ^ src2.toInt32(callFrame));
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
</ins><span class="cx"> DEFINE_STUB_FUNCTION(JSObject*, op_new_regexp)
</span><span class="cx"> {
</span><span class="cx">     STUB_INIT_STACK_FRAME(stackFrame);
</span><span class="lines">@@ -2013,6 +2285,20 @@
</span><span class="cx">     return RegExpObject::create(*stackFrame.vm, stackFrame.callFrame-&gt;lexicalGlobalObject(), stackFrame.callFrame-&gt;lexicalGlobalObject()-&gt;regExpStructure(), regExp);
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+DEFINE_STUB_FUNCTION(EncodedJSValue, op_bitor)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue src1 = stackFrame.args[0].jsValue();
+    JSValue src2 = stackFrame.args[1].jsValue();
+
+    CallFrame* callFrame = stackFrame.callFrame;
+
+    JSValue result = jsNumber(src1.toInt32(callFrame) | src2.toInt32(callFrame));
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
</ins><span class="cx"> DEFINE_STUB_FUNCTION(EncodedJSValue, op_call_eval)
</span><span class="cx"> {
</span><span class="cx">     STUB_INIT_STACK_FRAME(stackFrame);
</span><span class="lines">@@ -2085,6 +2371,106 @@
</span><span class="cx">     stackFrame.callFrame-&gt;setScope(stackFrame.callFrame-&gt;scope()-&gt;next());
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+DEFINE_STUB_FUNCTION(EncodedJSValue, op_typeof)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    return JSValue::encode(jsTypeStringForValue(stackFrame.callFrame, stackFrame.args[0].jsValue()));
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_is_object)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    return JSValue::encode(jsBoolean(jsIsObjectType(stackFrame.callFrame, stackFrame.args[0].jsValue())));
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_is_function)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    return JSValue::encode(jsBoolean(jsIsFunctionType(stackFrame.args[0].jsValue())));
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_stricteq)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue src1 = stackFrame.args[0].jsValue();
+    JSValue src2 = stackFrame.args[1].jsValue();
+    
+    bool result = JSValue::strictEqual(stackFrame.callFrame, src1, src2);
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(jsBoolean(result));
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_to_primitive)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    return JSValue::encode(stackFrame.args[0].jsValue().toPrimitive(stackFrame.callFrame));
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_strcat)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue result = jsString(stackFrame.callFrame, &amp;stackFrame.callFrame-&gt;registers()[stackFrame.args[0].int32()], stackFrame.args[1].int32());
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(result);
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_nstricteq)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue src1 = stackFrame.args[0].jsValue();
+    JSValue src2 = stackFrame.args[1].jsValue();
+
+    bool result = !JSValue::strictEqual(stackFrame.callFrame, src1, src2);
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(jsBoolean(result));
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_to_number)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    JSValue src = stackFrame.args[0].jsValue();
+    CallFrame* callFrame = stackFrame.callFrame;
+
+    double number = src.toNumber(callFrame);
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(jsNumber(number));
+}
+
+DEFINE_STUB_FUNCTION(EncodedJSValue, op_in)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    CallFrame* callFrame = stackFrame.callFrame;
+    JSValue baseVal = stackFrame.args[1].jsValue();
+
+    if (!baseVal.isObject()) {
+        stackFrame.vm-&gt;exception = createInvalidParamError(stackFrame.callFrame, &quot;in&quot;, baseVal);
+        VM_THROW_EXCEPTION();
+    }
+
+    JSValue propName = stackFrame.args[0].jsValue();
+    JSObject* baseObj = asObject(baseVal);
+
+    uint32_t i;
+    if (propName.getUInt32(i))
+        return JSValue::encode(jsBoolean(baseObj-&gt;hasProperty(callFrame, i)));
+
+    if (isName(propName))
+        return JSValue::encode(jsBoolean(baseObj-&gt;hasProperty(callFrame, jsCast&lt;NameInstance*&gt;(propName.asCell())-&gt;privateName())));
+
+    Identifier property(callFrame, propName.toString(callFrame)-&gt;value(callFrame));
+    CHECK_FOR_EXCEPTION();
+    return JSValue::encode(jsBoolean(baseObj-&gt;hasProperty(callFrame, property)));
+}
+
</ins><span class="cx"> DEFINE_STUB_FUNCTION(void, op_push_name_scope)
</span><span class="cx"> {
</span><span class="cx">     STUB_INIT_STACK_FRAME(stackFrame);
</span><span class="lines">@@ -2164,6 +2550,36 @@
</span><span class="cx">     return result;
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+DEFINE_STUB_FUNCTION(EncodedJSValue, op_del_by_val)
+{
+    STUB_INIT_STACK_FRAME(stackFrame);
+
+    CallFrame* callFrame = stackFrame.callFrame;
+
+    JSValue baseValue = stackFrame.args[0].jsValue();
+    JSObject* baseObj = baseValue.toObject(callFrame); // may throw
+
+    JSValue subscript = stackFrame.args[1].jsValue();
+    bool result;
+    uint32_t i;
+    if (subscript.getUInt32(i))
+        result = baseObj-&gt;methodTable()-&gt;deletePropertyByIndex(baseObj, callFrame, i);
+    else if (isName(subscript))
+        result = baseObj-&gt;methodTable()-&gt;deleteProperty(baseObj, callFrame, jsCast&lt;NameInstance*&gt;(subscript.asCell())-&gt;privateName());
+    else {
+        CHECK_FOR_EXCEPTION();
+        Identifier property(callFrame, subscript.toString(callFrame)-&gt;value(callFrame));
+        CHECK_FOR_EXCEPTION();
+        result = baseObj-&gt;methodTable()-&gt;deleteProperty(baseObj, callFrame, property);
+    }
+
+    if (!result &amp;&amp; callFrame-&gt;codeBlock()-&gt;isStrictMode())
+        stackFrame.vm-&gt;exception = createTypeError(stackFrame.callFrame, &quot;Unable to delete property.&quot;);
+
+    CHECK_FOR_EXCEPTION_AT_END();
+    return JSValue::encode(jsBoolean(result));
+}
+
</ins><span class="cx"> DEFINE_STUB_FUNCTION(void, op_put_getter_setter)
</span><span class="cx"> {
</span><span class="cx">     STUB_INIT_STACK_FRAME(stackFrame);
</span><span class="lines">@@ -2224,12 +2640,6 @@
</span><span class="cx">     return handler.callFrame;
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-ExceptionHandler JIT_STUB cti_vm_throw_slowpath(CallFrame* callFrame)
-{
-    VM* vm = callFrame-&gt;codeBlock()-&gt;vm();
-    return jitThrowNew(vm, callFrame, vm-&gt;exception);
-}
-
</del><span class="cx"> DEFINE_STUB_FUNCTION(EncodedJSValue, to_object)
</span><span class="cx"> {
</span><span class="cx">     STUB_INIT_STACK_FRAME(stackFrame);
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJITStubsh"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubs.h (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubs.h        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubs.h        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -32,7 +32,6 @@
</span><span class="cx"> 
</span><span class="cx"> #include &quot;CallData.h&quot;
</span><span class="cx"> #include &quot;Intrinsic.h&quot;
</span><del>-#include &quot;JITExceptions.h&quot;
</del><span class="cx"> #include &quot;LowLevelInterpreter.h&quot;
</span><span class="cx"> #include &quot;MacroAssemblerCodeRef.h&quot;
</span><span class="cx"> #include &quot;Register.h&quot;
</span><span class="lines">@@ -307,7 +306,6 @@
</span><span class="cx"> #endif
</span><span class="cx"> 
</span><span class="cx"> extern &quot;C&quot; void ctiVMThrowTrampoline();
</span><del>-extern &quot;C&quot; void ctiVMThrowTrampolineSlowpath();
</del><span class="cx"> extern &quot;C&quot; void ctiOpThrowNotCaught();
</span><span class="cx"> extern &quot;C&quot; EncodedJSValue ctiTrampoline(void* code, JSStack*, CallFrame*, void* /*unused1*/, void* /*unused2*/, VM*);
</span><span class="cx"> #if ENABLE(DFG_JIT)
</span><span class="lines">@@ -327,12 +325,20 @@
</span><span class="cx"> void performPlatformSpecificJITAssertions(VM*);
</span><span class="cx"> 
</span><span class="cx"> extern &quot;C&quot; {
</span><ins>+EncodedJSValue JIT_STUB cti_op_add(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_bitand(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_bitor(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_bitxor(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</ins><span class="cx"> EncodedJSValue JIT_STUB cti_op_call_NotJSFunction(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> EncodedJSValue JIT_STUB cti_op_call_eval(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> EncodedJSValue JIT_STUB cti_op_construct_NotJSConstruct(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> EncodedJSValue JIT_STUB cti_op_check_has_instance(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><ins>+EncodedJSValue JIT_STUB cti_op_create_this(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_to_this(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</ins><span class="cx"> EncodedJSValue JIT_STUB cti_op_create_arguments(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> EncodedJSValue JIT_STUB cti_op_del_by_id(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><ins>+EncodedJSValue JIT_STUB cti_op_del_by_val(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_div(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</ins><span class="cx"> EncodedJSValue JIT_STUB cti_op_get_by_id(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> EncodedJSValue JIT_STUB cti_op_get_by_id_array_fail(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> EncodedJSValue JIT_STUB cti_op_get_by_id_custom_stub(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="lines">@@ -346,11 +352,26 @@
</span><span class="cx"> EncodedJSValue JIT_STUB cti_op_get_by_val(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> EncodedJSValue JIT_STUB cti_op_get_by_val_generic(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> EncodedJSValue JIT_STUB cti_op_get_by_val_string(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><ins>+EncodedJSValue JIT_STUB cti_op_in(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</ins><span class="cx"> EncodedJSValue JIT_STUB cti_op_instanceof(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> EncodedJSValue JIT_STUB cti_op_is_boolean(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><ins>+EncodedJSValue JIT_STUB cti_op_is_function(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</ins><span class="cx"> EncodedJSValue JIT_STUB cti_op_is_number(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><ins>+EncodedJSValue JIT_STUB cti_op_is_object(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</ins><span class="cx"> EncodedJSValue JIT_STUB cti_op_is_string(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> EncodedJSValue JIT_STUB cti_op_is_undefined(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><ins>+EncodedJSValue JIT_STUB cti_op_less(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_lesseq(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_greater(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_greatereq(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_lshift(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_mod(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_mul(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_negate(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_not(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_nstricteq(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_dec(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_inc(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</ins><span class="cx"> EncodedJSValue JIT_STUB cti_op_resolve(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> EncodedJSValue JIT_STUB cti_op_resolve_base(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> EncodedJSValue JIT_STUB cti_op_resolve_base_strict_put(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="lines">@@ -358,6 +379,14 @@
</span><span class="cx"> EncodedJSValue JIT_STUB cti_op_resolve_with_base(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> EncodedJSValue JIT_STUB cti_op_resolve_with_this(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> void JIT_STUB cti_op_put_to_base(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><ins>+EncodedJSValue JIT_STUB cti_op_rshift(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_strcat(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_stricteq(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_sub(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_to_number(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_to_primitive(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_typeof(STUB_ARGS_DECLARATION) WTF_INTERNAL;
+EncodedJSValue JIT_STUB cti_op_urshift(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</ins><span class="cx"> EncodedJSValue JIT_STUB cti_to_object(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> JSObject* JIT_STUB cti_op_new_array(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> JSObject* JIT_STUB cti_op_new_array_with_size(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="lines">@@ -416,7 +445,6 @@
</span><span class="cx"> void* JIT_STUB cti_vm_lazyLinkClosureCall(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> void* JIT_STUB cti_vm_lazyLinkConstruct(STUB_ARGS_DECLARATION) WTF_INTERNAL;
</span><span class="cx"> void* JIT_STUB cti_vm_throw(STUB_ARGS_DECLARATION) REFERENCED_FROM_ASM WTF_INTERNAL;
</span><del>-ExceptionHandler JIT_STUB cti_vm_throw_slowpath(CallFrame*) REFERENCED_FROM_ASM WTF_INTERNAL;
</del><span class="cx"> } // extern &quot;C&quot;
</span><span class="cx"> 
</span><span class="cx"> #elif ENABLE(LLINT_C_LOOP)
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJITStubsARMh"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsARM.h (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsARM.h        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsARM.h        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -196,21 +196,6 @@
</span><span class="cx">     &quot;bx lr&quot; &quot;\n&quot;
</span><span class="cx"> );
</span><span class="cx"> 
</span><del>-asm (
-&quot;.text&quot; &quot;\n&quot;
-&quot;.globl &quot; SYMBOL_STRING(ctiVMThrowTrampolineSlowpath) &quot;\n&quot;
-HIDE_SYMBOL(ctiVMThrowTrampolineSlowpath) &quot;\n&quot;
-INLINE_ARM_FUNCTION(ctiVMThrowTrampolineSlowpath)
-SYMBOL_STRING(ctiVMThrowTrampolineSlowpath) &quot;:&quot; &quot;\n&quot;
-    &quot;mov r0, r5&quot; &quot;\n&quot;
-    &quot;bl &quot; SYMBOL_STRING(cti_vm_throw_slowpath) &quot;\n&quot;
-     // When cti_vm_throw_slowpath returns, r0 has callFrame and r1 has handler address
-     &quot;add sp, sp, #&quot; STRINGIZE_VALUE_OF(PRESERVEDR4_OFFSET) &quot;\n&quot;
-     &quot;ldmia sp!, {r4-r6, r8-r11, lr}&quot; &quot;\n&quot;
-     &quot;add sp, sp, #12&quot; &quot;\n&quot;
-     &quot;bx r1&quot; &quot;\n&quot;
-);
-
</del><span class="cx"> #if USE(MASM_PROBE)
</span><span class="cx"> asm (
</span><span class="cx"> &quot;.text&quot; &quot;\n&quot;
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJITStubsARMv7h"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsARMv7.h (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsARMv7.h        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsARMv7.h        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -270,30 +270,6 @@
</span><span class="cx"> asm (
</span><span class="cx"> &quot;.text&quot; &quot;\n&quot;
</span><span class="cx"> &quot;.align 2&quot; &quot;\n&quot;
</span><del>-&quot;.globl &quot; SYMBOL_STRING(ctiVMThrowTrampolineSlowpath) &quot;\n&quot;
-HIDE_SYMBOL(ctiVMThrowTrampolineSlowpath) &quot;\n&quot;
-&quot;.thumb&quot; &quot;\n&quot;
-&quot;.thumb_func &quot; THUMB_FUNC_PARAM(ctiVMThrowTrampolineSlowpath) &quot;\n&quot;
-SYMBOL_STRING(ctiVMThrowTrampolineSlowpath) &quot;:&quot; &quot;\n&quot;
-    &quot;mov r0, r5&quot; &quot;\n&quot;
-    &quot;bl &quot; LOCAL_REFERENCE(cti_vm_throw_slowpath) &quot;\n&quot;
-     // When cti_vm_throw_slowpath returns, r0 has callFrame and r1 has handler address
-    &quot;ldr r11, [sp, #&quot; STRINGIZE_VALUE_OF(PRESERVED_R11_OFFSET) &quot;]&quot; &quot;\n&quot;
-    &quot;ldr r10, [sp, #&quot; STRINGIZE_VALUE_OF(PRESERVED_R10_OFFSET) &quot;]&quot; &quot;\n&quot;
-    &quot;ldr r9, [sp, #&quot; STRINGIZE_VALUE_OF(PRESERVED_R9_OFFSET) &quot;]&quot; &quot;\n&quot;
-    &quot;ldr r8, [sp, #&quot; STRINGIZE_VALUE_OF(PRESERVED_R8_OFFSET) &quot;]&quot; &quot;\n&quot;
-    &quot;ldr r7, [sp, #&quot; STRINGIZE_VALUE_OF(PRESERVED_R7_OFFSET) &quot;]&quot; &quot;\n&quot;
-    &quot;ldr r6, [sp, #&quot; STRINGIZE_VALUE_OF(PRESERVED_R6_OFFSET) &quot;]&quot; &quot;\n&quot;
-    &quot;ldr r5, [sp, #&quot; STRINGIZE_VALUE_OF(PRESERVED_R5_OFFSET) &quot;]&quot; &quot;\n&quot;
-    &quot;ldr r4, [sp, #&quot; STRINGIZE_VALUE_OF(PRESERVED_R4_OFFSET) &quot;]&quot; &quot;\n&quot;
-    &quot;ldr lr, [sp, #&quot; STRINGIZE_VALUE_OF(PRESERVED_RETURN_ADDRESS_OFFSET) &quot;]&quot; &quot;\n&quot;
-    &quot;add sp, sp, #&quot; STRINGIZE_VALUE_OF(FIRST_STACK_ARGUMENT) &quot;\n&quot;
-    &quot;bx r1&quot; &quot;\n&quot;
-);
-
-asm (
-&quot;.text&quot; &quot;\n&quot;
-&quot;.align 2&quot; &quot;\n&quot;
</del><span class="cx"> &quot;.globl &quot; SYMBOL_STRING(ctiOpThrowNotCaught) &quot;\n&quot;
</span><span class="cx"> HIDE_SYMBOL(ctiOpThrowNotCaught) &quot;\n&quot;
</span><span class="cx"> &quot;.thumb&quot; &quot;\n&quot;
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJITStubsMIPSh"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsMIPS.h (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsMIPS.h        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsMIPS.h        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -133,40 +133,6 @@
</span><span class="cx"> &quot;.set noreorder&quot; &quot;\n&quot;
</span><span class="cx"> &quot;.set nomacro&quot; &quot;\n&quot;
</span><span class="cx"> &quot;.set nomips16&quot; &quot;\n&quot;
</span><del>-&quot;.globl &quot; SYMBOL_STRING(ctiVMThrowTrampolineSlowpath) &quot;\n&quot;
-&quot;.ent &quot; SYMBOL_STRING(ctiVMThrowTrampolineSlowpath) &quot;\n&quot;
-SYMBOL_STRING(ctiVMThrowTrampolineSlowpath) &quot;:&quot; &quot;\n&quot;
-#if WTF_MIPS_PIC
-&quot;.set macro&quot; &quot;\n&quot;
-&quot;.cpload $31&quot; &quot;\n&quot;
-    &quot;la    $25,&quot; SYMBOL_STRING(cti_vm_throw_slowpath) &quot;\n&quot;
-&quot;.set nomacro&quot; &quot;\n&quot;
-    &quot;bal &quot; SYMBOL_STRING(cti_vm_throw_slowpath) &quot;\n&quot;
-    &quot;move  $4,$16&quot; &quot;\n&quot;
-#else
-    &quot;jal &quot; SYMBOL_STRING(cti_vm_throw_slowpath) &quot;\n&quot;
-    &quot;move  $4,$16&quot; &quot;\n&quot;
-#endif
-    // When cti_vm_throw_slowpath returns, v0 has callFrame and v1 has handler address
-    &quot;lw    $16,&quot; STRINGIZE_VALUE_OF(PRESERVED_S0_OFFSET) &quot;($29)&quot; &quot;\n&quot;
-    &quot;lw    $17,&quot; STRINGIZE_VALUE_OF(PRESERVED_S1_OFFSET) &quot;($29)&quot; &quot;\n&quot;
-    &quot;lw    $18,&quot; STRINGIZE_VALUE_OF(PRESERVED_S2_OFFSET) &quot;($29)&quot; &quot;\n&quot;
-    &quot;lw    $19,&quot; STRINGIZE_VALUE_OF(PRESERVED_S3_OFFSET) &quot;($29)&quot; &quot;\n&quot;
-    &quot;lw    $20,&quot; STRINGIZE_VALUE_OF(PRESERVED_S4_OFFSET) &quot;($29)&quot; &quot;\n&quot;
-    &quot;lw    $31,&quot; STRINGIZE_VALUE_OF(PRESERVED_RETURN_ADDRESS_OFFSET) &quot;($29)&quot; &quot;\n&quot;
-    &quot;jr    $3&quot; &quot;\n&quot;
-    &quot;addiu $29,$29,&quot; STRINGIZE_VALUE_OF(STACK_LENGTH) &quot;\n&quot;
-&quot;.set reorder&quot; &quot;\n&quot;
-&quot;.set macro&quot; &quot;\n&quot;
-&quot;.end &quot; SYMBOL_STRING(ctiVMThrowTrampolineSlowpath) &quot;\n&quot;
-);
-
-asm (
-&quot;.text&quot; &quot;\n&quot;
-&quot;.align 2&quot; &quot;\n&quot;
-&quot;.set noreorder&quot; &quot;\n&quot;
-&quot;.set nomacro&quot; &quot;\n&quot;
-&quot;.set nomips16&quot; &quot;\n&quot;
</del><span class="cx"> &quot;.globl &quot; SYMBOL_STRING(ctiOpThrowNotCaught) &quot;\n&quot;
</span><span class="cx"> &quot;.ent &quot; SYMBOL_STRING(ctiOpThrowNotCaught) &quot;\n&quot;
</span><span class="cx"> SYMBOL_STRING(ctiOpThrowNotCaught) &quot;:&quot; &quot;\n&quot;
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJITStubsSH4h"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsSH4.h (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsSH4.h        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsSH4.h        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -99,31 +99,6 @@
</span><span class="cx"> );
</span><span class="cx"> 
</span><span class="cx"> asm volatile (
</span><del>-&quot;.globl &quot; SYMBOL_STRING(ctiVMThrowTrampolineSlowpath) &quot;\n&quot;
-HIDE_SYMBOL(ctiVMThrowTrampolineSlowpath) &quot;\n&quot;
-SYMBOL_STRING(ctiVMThrowTrampolineSlowpath) &quot;:&quot; &quot;\n&quot;
-    &quot;mov.l .L2&quot;SYMBOL_STRING(cti_vm_throw_slowpath)&quot;,r0&quot; &quot;\n&quot;
-    &quot;mov r15, r4&quot; &quot;\n&quot;
-    &quot;mov.l @(r0,r12),r11&quot; &quot;\n&quot;
-    &quot;jsr @r11&quot; &quot;\n&quot;
-    // When cti_vm_throw_slowpath returns, r0 has callFrame and r1 has handler address
-    &quot;nop&quot; &quot;\n&quot;
-    &quot;add #60, r15&quot; &quot;\n&quot;
-    &quot;mov.l @r15+,r10&quot; &quot;\n&quot;
-    &quot;mov.l @r15+,r11&quot; &quot;\n&quot;
-    &quot;mov.l @r15+,r13&quot; &quot;\n&quot;
-    &quot;lds.l @r15+,pr&quot; &quot;\n&quot;
-    &quot;mov.l @r15+,r14&quot; &quot;\n&quot;
-    &quot;mov.l @r15+,r8&quot; &quot;\n&quot;
-    &quot;add #12, r15&quot; &quot;\n&quot;
-    &quot;mov r0, r4&quot; &quot;\n&quot;
-    &quot;jmp @r1&quot; &quot;\n&quot;
-    &quot;nop&quot; &quot;\n&quot;
-    &quot;.align 2&quot; &quot;\n&quot;
-    &quot;.L2&quot;SYMBOL_STRING(cti_vm_throw_slowpath)&quot;:.long &quot; SYMBOL_STRING(cti_vm_throw_slowpath)&quot;@GOT \n&quot;
-);
-
-asm volatile (
</del><span class="cx"> &quot;.globl &quot; SYMBOL_STRING(ctiOpThrowNotCaught) &quot;\n&quot;
</span><span class="cx"> HIDE_SYMBOL(ctiOpThrowNotCaught) &quot;\n&quot;
</span><span class="cx"> SYMBOL_STRING(ctiOpThrowNotCaught) &quot;:&quot; &quot;\n&quot;
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJITStubsX86h"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsX86.h (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsX86.h        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsX86.h        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -86,16 +86,6 @@
</span><span class="cx"> );
</span><span class="cx"> 
</span><span class="cx"> asm (
</span><del>-&quot;.globl &quot; SYMBOL_STRING(ctiVMThrowTrampolineSlowpath) &quot;\n&quot;
-HIDE_SYMBOL(ctiVMThrowTrampolineSlowpath) &quot;\n&quot;
-SYMBOL_STRING(ctiVMThrowTrampolineSlowpath) &quot;:&quot; &quot;\n&quot;
-    &quot;movl %edi, %ecx&quot; &quot;\n&quot;
-    &quot;call &quot; LOCAL_REFERENCE(cti_vm_throw_slowpath) &quot;\n&quot;
-    // When cti_vm_throw_slowpath returns, eax has callFrame and edx has handler address
-    &quot;jmp *%edx&quot; &quot;\n&quot;
-);
-
-asm (
</del><span class="cx"> &quot;.globl &quot; SYMBOL_STRING(ctiOpThrowNotCaught) &quot;\n&quot;
</span><span class="cx"> HIDE_SYMBOL(ctiOpThrowNotCaught) &quot;\n&quot;
</span><span class="cx"> SYMBOL_STRING(ctiOpThrowNotCaught) &quot;:&quot; &quot;\n&quot;
</span><span class="lines">@@ -309,22 +299,6 @@
</span><span class="cx">         }
</span><span class="cx">     }
</span><span class="cx"> 
</span><del>-    __declspec(naked) void ctiVMThrowTrampolineSlowpath()
-    {
-        __asm {
-            mov ecx, edi;
-            call cti_vm_throw_slowpath;
-            // When cti_vm_throw_slowpath returns, eax has callFrame and edx has handler address
-            add esp, 0x3c;
-            pop ebx;
-            pop edi;
-            pop esi;
-            pop ebp;
-            jmp edx
-            ret;
-        }
-    }
-
</del><span class="cx">     __declspec(naked) void ctiOpThrowNotCaught()
</span><span class="cx">     {
</span><span class="cx">         __asm {
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJITStubsX86_64h"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsX86_64.h (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsX86_64.h        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JITStubsX86_64.h        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -99,16 +99,6 @@
</span><span class="cx"> );
</span><span class="cx"> 
</span><span class="cx"> asm (
</span><del>-&quot;.globl &quot; SYMBOL_STRING(ctiVMThrowTrampolineSlowpath) &quot;\n&quot;
-HIDE_SYMBOL(ctiVMThrowTrampolineSlowpath) &quot;\n&quot;
-SYMBOL_STRING(ctiVMThrowTrampolineSlowpath) &quot;:&quot; &quot;\n&quot;
-    &quot;movq %r13, %rdi&quot; &quot;\n&quot;
-    &quot;call &quot; LOCAL_REFERENCE(cti_vm_throw_slowpath) &quot;\n&quot;
-    // When cti_vm_throw_slowpath returns, rax has callFrame and rdx has handler address
-    &quot;jmp *%rdx&quot; &quot;\n&quot;
-);
-
-asm (
</del><span class="cx"> &quot;.globl &quot; SYMBOL_STRING(ctiOpThrowNotCaught) &quot;\n&quot;
</span><span class="cx"> HIDE_SYMBOL(ctiOpThrowNotCaught) &quot;\n&quot;
</span><span class="cx"> SYMBOL_STRING(ctiOpThrowNotCaught) &quot;:&quot; &quot;\n&quot;
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitJSInterfaceJITh"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/JSInterfaceJIT.h (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/JSInterfaceJIT.h        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/JSInterfaceJIT.h        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -59,10 +59,8 @@
</span><span class="cx">         static const RegisterID cachedResultRegister = X86Registers::eax;
</span><span class="cx"> #if !OS(WINDOWS)
</span><span class="cx">         static const RegisterID firstArgumentRegister = X86Registers::edi;
</span><del>-        static const RegisterID secondArgumentRegister = X86Registers::esi;
</del><span class="cx"> #else
</span><span class="cx">         static const RegisterID firstArgumentRegister = X86Registers::ecx;
</span><del>-        static const RegisterID secondArgumentRegister = X86Registers::edx;
</del><span class="cx"> #endif
</span><span class="cx"> 
</span><span class="cx"> #if ENABLE(VALUE_PROFILER)
</span><span class="lines">@@ -90,7 +88,6 @@
</span><span class="cx">         // On x86 we always use fastcall conventions = but on
</span><span class="cx">         // OS X if might make more sense to just use regparm.
</span><span class="cx">         static const RegisterID firstArgumentRegister = X86Registers::ecx;
</span><del>-        static const RegisterID secondArgumentRegister = X86Registers::edx;
</del><span class="cx">         
</span><span class="cx">         static const RegisterID bucketCounterRegister = X86Registers::esi;
</span><span class="cx">         static const RegisterID callFrameRegister = X86Registers::edi;
</span><span class="lines">@@ -108,7 +105,6 @@
</span><span class="cx">         static const RegisterID returnValueRegister = ARMRegisters::r0;
</span><span class="cx">         static const RegisterID cachedResultRegister = ARMRegisters::r0;
</span><span class="cx">         static const RegisterID firstArgumentRegister = ARMRegisters::r0;
</span><del>-        static const RegisterID secondArgumentRegister = ARMRegisters::r1;
</del><span class="cx"> 
</span><span class="cx"> #if ENABLE(VALUE_PROFILER)
</span><span class="cx">         static const RegisterID bucketCounterRegister = ARMRegisters::r7;
</span><span class="lines">@@ -130,7 +126,6 @@
</span><span class="cx">         static const RegisterID returnValueRegister = MIPSRegisters::v0;
</span><span class="cx">         static const RegisterID cachedResultRegister = MIPSRegisters::v0;
</span><span class="cx">         static const RegisterID firstArgumentRegister = MIPSRegisters::a0;
</span><del>-        static const RegisterID secondArgumentRegister = MIPSRegisters::a1;
</del><span class="cx">         
</span><span class="cx"> #if ENABLE(VALUE_PROFILER)
</span><span class="cx">         static const RegisterID bucketCounterRegister = MIPSRegisters::s3;
</span><span class="lines">@@ -165,7 +160,6 @@
</span><span class="cx">         static const RegisterID regT6 = SH4Registers::r6;
</span><span class="cx">         static const RegisterID regT7 = SH4Registers::r7;
</span><span class="cx">         static const RegisterID firstArgumentRegister =regT4;
</span><del>-        static const RegisterID secondArgumentRegister =regT4;
</del><span class="cx"> 
</span><span class="cx">         static const RegisterID returnValueRegister = SH4Registers::r0;
</span><span class="cx">         static const RegisterID cachedResultRegister = SH4Registers::r0;
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitSlowPathCallh"></a>
<div class="delfile"><h4>Deleted: branches/dfgFourthTier/Source/JavaScriptCore/jit/SlowPathCall.h (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/SlowPathCall.h        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/SlowPathCall.h        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -1,100 +0,0 @@
</span><del>-/*
- * Copyright (C) 2013 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
- */
-
-#ifndef SlowPathCall_h
-#define SlowPathCall_h
-
-#include &quot;CommonSlowPaths.h&quot;
-#include &quot;MacroAssemblerCodeRef.h&quot;
-
-#if ENABLE(JIT)
-
-namespace JSC {
-
-class JITSlowPathCall {
-public:
-    JITSlowPathCall(JIT* jit, Instruction* pc, SlowPathReturnType (SLOW_PATH *stub)(ExecState* exec, Instruction* pc))
-        : m_jit(jit)
-        , m_stub(stub)
-        , m_pc(pc)
-    {
-    }
-
-    JIT::Call call()
-    {
-#if ENABLE(OPCODE_SAMPLING)
-        if (m_jit-&gt;m_bytecodeOffset != (unsigned)-1)
-            m_jit-&gt;sampleInstruction(m_jit-&gt;m_codeBlock-&gt;instructions().begin() + m_jit-&gt;m_bytecodeOffset, true);
-#endif
-        m_jit-&gt;updateTopCallFrame();
-#if CPU(X86) &amp;&amp; USE(JSVALUE32_64)
-        m_jit-&gt;addPtr(MacroAssembler::TrustedImm32(-8), MacroAssembler::stackPointerRegister);
-        m_jit-&gt;push(JIT::TrustedImm32(JIT::TrustedImmPtr(m_pc)));
-        m_jit-&gt;push(JIT::callFrameRegister);
-#else
-        m_jit-&gt;move(JIT::callFrameRegister, JIT::firstArgumentRegister);
-        m_jit-&gt;move(JIT::TrustedImmPtr(m_pc), JIT::secondArgumentRegister);
-#endif
-        JIT::Call call = m_jit-&gt;call();
-        m_jit-&gt;m_calls.append(CallRecord(call, m_jit-&gt;m_bytecodeOffset, m_stub.value()));
-
-#if CPU(X86) &amp;&amp; USE(JSVALUE32_64)
-        m_jit-&gt;addPtr(MacroAssembler::TrustedImm32(16), MacroAssembler::stackPointerRegister);
-#endif
-
-#if ENABLE(OPCODE_SAMPLING)
-        if (m_jit-&gt;m_bytecodeOffset != (unsigned)-1)
-            m_jit-&gt;sampleInstruction(m_jit-&gt;m_codeBlock-&gt;instructions().begin() + m_jit-&gt;m_bytecodeOffset, false);
-#endif
-        
-#if USE(JSVALUE32_64)
-        m_jit-&gt;unmap();
-#else
-        m_jit-&gt;killLastResultRegister();
-#endif
-        
-#if USE(JSVALUE32_64)
-        JIT::Jump noException = m_jit-&gt;branch32(JIT::Equal, JIT::AbsoluteAddress(reinterpret_cast&lt;char*&gt;(&amp;m_jit-&gt;m_codeBlock-&gt;vm()-&gt;exception) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), JIT::TrustedImm32(JSValue::EmptyValueTag));
-#else
-        JIT::Jump noException = m_jit-&gt;branchTest64(JIT::Zero, JIT::AbsoluteAddress(&amp;m_jit-&gt;m_codeBlock-&gt;vm()-&gt;exception));
-#endif
-        m_jit-&gt;move(JIT::TrustedImmPtr(FunctionPtr(ctiVMThrowTrampolineSlowpath).value()), JIT::regT1);
-        m_jit-&gt;jump(JIT::regT1);
-        noException.link(m_jit);
-        
-        return call;
-    }
-
-private:
-    JIT* m_jit;
-    FunctionPtr m_stub;
-    Instruction* m_pc;
-};
-
-} // namespace JS
-
-#endif // ENABLE(JIT)
-
-#endif // SlowPathCall_h
</del></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorejitThunkGeneratorscpp"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/jit/ThunkGenerators.cpp (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/jit/ThunkGenerators.cpp        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/jit/ThunkGenerators.cpp        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -395,14 +395,17 @@
</span><span class="cx"> 
</span><span class="cx">     // Grab the return address.
</span><span class="cx">     jit.preserveReturnAddressAfterCall(JSInterfaceJIT::regT1);
</span><del>-    
</del><ins>+
</ins><span class="cx">     jit.move(JSInterfaceJIT::TrustedImmPtr(&amp;vm-&gt;exceptionLocation), JSInterfaceJIT::regT2);
</span><span class="cx">     jit.storePtr(JSInterfaceJIT::regT1, JSInterfaceJIT::regT2);
</span><ins>+    jit.poke(JSInterfaceJIT::callFrameRegister, OBJECT_OFFSETOF(struct JITStackFrame, callFrame) / sizeof(void*));
</ins><span class="cx"> 
</span><span class="cx">     jit.storePtr(JSInterfaceJIT::callFrameRegister, &amp;vm-&gt;topCallFrame);
</span><ins>+    // Set the return address.
+    jit.move(JSInterfaceJIT::TrustedImmPtr(FunctionPtr(ctiVMThrowTrampoline).value()), JSInterfaceJIT::regT1);
+    jit.restoreReturnAddressBeforeReturn(JSInterfaceJIT::regT1);
</ins><span class="cx"> 
</span><del>-    jit.move(JSInterfaceJIT::TrustedImmPtr(FunctionPtr(ctiVMThrowTrampolineSlowpath).value()), JSInterfaceJIT::regT1);
-    jit.jump(JSInterfaceJIT::regT1);
</del><ins>+    jit.ret();
</ins><span class="cx"> 
</span><span class="cx">     LinkBuffer patchBuffer(*vm, &amp;jit, GLOBAL_THUNK_ID);
</span><span class="cx">     return FINALIZE_CODE(patchBuffer, (&quot;native %s trampoline&quot;, toCString(kind).data()));
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorellintLLIntSlowPathscpp"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/llint/LLIntSlowPaths.cpp        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -428,6 +428,34 @@
</span><span class="cx">     LLINT_END_IMPL();
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+LLINT_SLOW_PATH_DECL(slow_path_call_arityCheck)
+{
+    LLINT_BEGIN();
+    ExecState* newExec = CommonSlowPaths::arityCheckFor(exec, &amp;vm.interpreter-&gt;stack(), CodeForCall);
+    if (!newExec) {
+        ReturnAddressPtr returnPC = exec-&gt;returnPC();
+        exec = exec-&gt;callerFrame();
+        vm.exception = createStackOverflowError(exec);
+        interpreterThrowInCaller(exec, returnPC);
+        LLINT_RETURN_TWO(bitwise_cast&lt;void*&gt;(static_cast&lt;uintptr_t&gt;(1)), exec);
+    }
+    LLINT_RETURN_TWO(0, newExec);
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_construct_arityCheck)
+{
+    LLINT_BEGIN();
+    ExecState* newExec = CommonSlowPaths::arityCheckFor(exec, &amp;vm.interpreter-&gt;stack(), CodeForConstruct);
+    if (!newExec) {
+        ReturnAddressPtr returnPC = exec-&gt;returnPC();
+        exec = exec-&gt;callerFrame();
+        vm.exception = createStackOverflowError(exec);
+        interpreterThrowInCaller(exec, returnPC);
+        LLINT_RETURN_TWO(bitwise_cast&lt;void*&gt;(static_cast&lt;uintptr_t&gt;(1)), exec);
+    }
+    LLINT_RETURN_TWO(0, newExec);
+}
+
</ins><span class="cx"> LLINT_SLOW_PATH_DECL(slow_path_create_activation)
</span><span class="cx"> {
</span><span class="cx">     LLINT_BEGIN();
</span><span class="lines">@@ -439,6 +467,42 @@
</span><span class="cx">     LLINT_RETURN(JSValue(activation));
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+LLINT_SLOW_PATH_DECL(slow_path_create_arguments)
+{
+    LLINT_BEGIN();
+    JSValue arguments = JSValue(Arguments::create(vm, exec));
+    LLINT_CHECK_EXCEPTION();
+    exec-&gt;uncheckedR(pc[1].u.operand) = arguments;
+    exec-&gt;uncheckedR(unmodifiedArgumentsRegister(pc[1].u.operand)) = arguments;
+    LLINT_END();
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_create_this)
+{
+    LLINT_BEGIN();
+    JSFunction* constructor = jsCast&lt;JSFunction*&gt;(LLINT_OP(2).jsValue().asCell());
+    
+#if !ASSERT_DISABLED
+    ConstructData constructData;
+    ASSERT(constructor-&gt;methodTable()-&gt;getConstructData(constructor, constructData) == ConstructTypeJS);
+#endif
+
+    size_t inlineCapacity = pc[3].u.operand;
+    Structure* structure = constructor-&gt;allocationProfile(exec, inlineCapacity)-&gt;structure();
+    LLINT_RETURN(constructEmptyObject(exec, structure));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_to_this)
+{
+    LLINT_BEGIN();
+    JSValue v1 = LLINT_OP(1).jsValue();
+#if ENABLE(VALUE_PROFILER)
+    pc[OPCODE_LENGTH(op_to_this) - 1].u.profile-&gt;m_buckets[0] =
+        JSValue::encode(v1.structureOrUndefined());
+#endif
+    LLINT_RETURN(v1.toThis(exec, exec-&gt;codeBlock()-&gt;isStrictMode() ? StrictMode : NotStrictMode));
+}
+
</ins><span class="cx"> LLINT_SLOW_PATH_DECL(slow_path_new_object)
</span><span class="cx"> {
</span><span class="cx">     LLINT_BEGIN();
</span><span class="lines">@@ -472,6 +536,187 @@
</span><span class="cx">     LLINT_RETURN(RegExpObject::create(vm, exec-&gt;lexicalGlobalObject(), exec-&gt;lexicalGlobalObject()-&gt;regExpStructure(), regExp));
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+LLINT_SLOW_PATH_DECL(slow_path_not)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsBoolean(!LLINT_OP_C(2).jsValue().toBoolean(exec)));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_eq)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsBoolean(JSValue::equal(exec, LLINT_OP_C(2).jsValue(), LLINT_OP_C(3).jsValue())));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_neq)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsBoolean(!JSValue::equal(exec, LLINT_OP_C(2).jsValue(), LLINT_OP_C(3).jsValue())));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_stricteq)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsBoolean(JSValue::strictEqual(exec, LLINT_OP_C(2).jsValue(), LLINT_OP_C(3).jsValue())));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_nstricteq)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsBoolean(!JSValue::strictEqual(exec, LLINT_OP_C(2).jsValue(), LLINT_OP_C(3).jsValue())));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_less)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsBoolean(jsLess&lt;true&gt;(exec, LLINT_OP_C(2).jsValue(), LLINT_OP_C(3).jsValue())));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_lesseq)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsBoolean(jsLessEq&lt;true&gt;(exec, LLINT_OP_C(2).jsValue(), LLINT_OP_C(3).jsValue())));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_greater)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsBoolean(jsLess&lt;false&gt;(exec, LLINT_OP_C(3).jsValue(), LLINT_OP_C(2).jsValue())));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_greatereq)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsBoolean(jsLessEq&lt;false&gt;(exec, LLINT_OP_C(3).jsValue(), LLINT_OP_C(2).jsValue())));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_pre_inc)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsNumber(LLINT_OP(1).jsValue().toNumber(exec) + 1));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_pre_dec)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsNumber(LLINT_OP(1).jsValue().toNumber(exec) - 1));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_to_number)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsNumber(LLINT_OP_C(2).jsValue().toNumber(exec)));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_negate)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsNumber(-LLINT_OP_C(2).jsValue().toNumber(exec)));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_add)
+{
+    LLINT_BEGIN();
+    JSValue v1 = LLINT_OP_C(2).jsValue();
+    JSValue v2 = LLINT_OP_C(3).jsValue();
+    
+#if LLINT_SLOW_PATH_TRACING
+    dataLog(&quot;Trying to add &quot;, v1, &quot; to &quot;, v2, &quot;.\n&quot;);
+#endif
+    
+    if (v1.isString() &amp;&amp; !v2.isObject())
+        LLINT_RETURN(jsString(exec, asString(v1), v2.toString(exec)));
+    
+    if (v1.isNumber() &amp;&amp; v2.isNumber())
+        LLINT_RETURN(jsNumber(v1.asNumber() + v2.asNumber()));
+    
+    LLINT_RETURN(jsAddSlowCase(exec, v1, v2));
+}
+
+// The following arithmetic and bitwise operations need to be sure to run
+// toNumber() on their operands in order.  (A call to toNumber() is idempotent
+// if an exception is already set on the ExecState.)
+
+LLINT_SLOW_PATH_DECL(slow_path_mul)
+{
+    LLINT_BEGIN();
+    double a = LLINT_OP_C(2).jsValue().toNumber(exec);
+    double b = LLINT_OP_C(3).jsValue().toNumber(exec);
+    LLINT_RETURN(jsNumber(a * b));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_sub)
+{
+    LLINT_BEGIN();
+    double a = LLINT_OP_C(2).jsValue().toNumber(exec);
+    double b = LLINT_OP_C(3).jsValue().toNumber(exec);
+    LLINT_RETURN(jsNumber(a - b));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_div)
+{
+    LLINT_BEGIN();
+    double a = LLINT_OP_C(2).jsValue().toNumber(exec);
+    double b = LLINT_OP_C(3).jsValue().toNumber(exec);
+    LLINT_RETURN(jsNumber(a / b));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_mod)
+{
+    LLINT_BEGIN();
+    double a = LLINT_OP_C(2).jsValue().toNumber(exec);
+    double b = LLINT_OP_C(3).jsValue().toNumber(exec);
+    LLINT_RETURN(jsNumber(fmod(a, b)));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_lshift)
+{
+    LLINT_BEGIN();
+    int32_t a = LLINT_OP_C(2).jsValue().toInt32(exec);
+    uint32_t b = LLINT_OP_C(3).jsValue().toUInt32(exec);
+    LLINT_RETURN(jsNumber(a &lt;&lt; (b &amp; 31)));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_rshift)
+{
+    LLINT_BEGIN();
+    int32_t a = LLINT_OP_C(2).jsValue().toInt32(exec);
+    uint32_t b = LLINT_OP_C(3).jsValue().toUInt32(exec);
+    LLINT_RETURN(jsNumber(a &gt;&gt; (b &amp; 31)));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_urshift)
+{
+    LLINT_BEGIN();
+    uint32_t a = LLINT_OP_C(2).jsValue().toUInt32(exec);
+    uint32_t b = LLINT_OP_C(3).jsValue().toUInt32(exec);
+    LLINT_RETURN(jsNumber(a &gt;&gt; (b &amp; 31)));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_bitand)
+{
+    LLINT_BEGIN();
+    int32_t a = LLINT_OP_C(2).jsValue().toInt32(exec);
+    int32_t b = LLINT_OP_C(3).jsValue().toInt32(exec);
+    LLINT_RETURN(jsNumber(a &amp; b));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_bitor)
+{
+    LLINT_BEGIN();
+    int32_t a = LLINT_OP_C(2).jsValue().toInt32(exec);
+    int32_t b = LLINT_OP_C(3).jsValue().toInt32(exec);
+    LLINT_RETURN(jsNumber(a | b));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_bitxor)
+{
+    LLINT_BEGIN();
+    int32_t a = LLINT_OP_C(2).jsValue().toInt32(exec);
+    int32_t b = LLINT_OP_C(3).jsValue().toInt32(exec);
+    LLINT_RETURN(jsNumber(a ^ b));
+}
+
</ins><span class="cx"> LLINT_SLOW_PATH_DECL(slow_path_check_has_instance)
</span><span class="cx"> {
</span><span class="cx">     LLINT_BEGIN();
</span><span class="lines">@@ -498,6 +743,30 @@
</span><span class="cx">     LLINT_RETURN(jsBoolean(JSObject::defaultHasInstance(exec, value, proto)));
</span><span class="cx"> }
</span><span class="cx"> 
</span><ins>+LLINT_SLOW_PATH_DECL(slow_path_typeof)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsTypeStringForValue(exec, LLINT_OP_C(2).jsValue()));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_is_object)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsBoolean(jsIsObjectType(exec, LLINT_OP_C(2).jsValue())));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_is_function)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsBoolean(jsIsFunctionType(LLINT_OP_C(2).jsValue())));
+}
+
+LLINT_SLOW_PATH_DECL(slow_path_in)
+{
+    LLINT_BEGIN();
+    LLINT_RETURN(jsBoolean(CommonSlowPaths::opIn(exec, LLINT_OP_C(2).jsValue(), LLINT_OP_C(3).jsValue())));
+}
+
</ins><span class="cx"> LLINT_SLOW_PATH_DECL(slow_path_resolve)
</span><span class="cx"> {
</span><span class="cx">     LLINT_BEGIN();
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorellintLLIntSlowPathsh"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/llint/LLIntSlowPaths.h (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/llint/LLIntSlowPaths.h        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/llint/LLIntSlowPaths.h        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -26,7 +26,6 @@
</span><span class="cx"> #ifndef LLIntSlowPaths_h
</span><span class="cx"> #define LLIntSlowPaths_h
</span><span class="cx"> 
</span><del>-#include &quot;CommonSlowPaths.h&quot;
</del><span class="cx"> #include &lt;wtf/Platform.h&gt;
</span><span class="cx"> #include &lt;wtf/StdLibExtras.h&gt;
</span><span class="cx"> 
</span><span class="lines">@@ -39,6 +38,57 @@
</span><span class="cx"> 
</span><span class="cx"> namespace LLInt {
</span><span class="cx"> 
</span><ins>+#if USE(JSVALUE64)
+// According to C++ rules, a type used for the return signature of function with C linkage (i.e.
+// 'extern &quot;C&quot;') needs to be POD; hence putting any constructors into it could cause either compiler
+// warnings, or worse, a change in the ABI used to return these types.
+struct SlowPathReturnType {
+    void* a;
+    ExecState* b;
+};
+
+inline SlowPathReturnType encodeResult(void* a, ExecState* b)
+{
+    SlowPathReturnType result;
+    result.a = a;
+    result.b = b;
+    return result;
+}
+
+inline void decodeResult(SlowPathReturnType result, void*&amp; a, ExecState*&amp; b)
+{
+    a = result.a;
+    b = result.b;
+}
+
+#else // USE(JSVALUE32_64)
+typedef int64_t SlowPathReturnType;
+
+typedef union {
+    struct {
+        void* a;
+        ExecState* b;
+    } pair;
+    int64_t i;
+} SlowPathReturnTypeEncoding;
+
+inline SlowPathReturnType encodeResult(void* a, ExecState* b)
+{
+    SlowPathReturnTypeEncoding u;
+    u.pair.a = a;
+    u.pair.b = b;
+    return u.i;
+}
+
+inline void decodeResult(SlowPathReturnType result, void*&amp; a, ExecState*&amp; b)
+{
+    SlowPathReturnTypeEncoding u;
+    u.i = result;
+    a = u.pair.a;
+    b = u.pair.b;
+}
+#endif // USE(JSVALUE32_64)
+
</ins><span class="cx"> extern &quot;C&quot; SlowPathReturnType llint_trace_operand(ExecState*, Instruction*, int fromWhere, int operand);
</span><span class="cx"> extern &quot;C&quot; SlowPathReturnType llint_trace_value(ExecState*, Instruction*, int fromWhere, int operand);
</span><span class="cx"> 
</span><span class="lines">@@ -63,14 +113,47 @@
</span><span class="cx"> LLINT_SLOW_PATH_HIDDEN_DECL(loop_osr);
</span><span class="cx"> LLINT_SLOW_PATH_HIDDEN_DECL(replace);
</span><span class="cx"> LLINT_SLOW_PATH_HIDDEN_DECL(stack_check);
</span><ins>+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_call_arityCheck);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_construct_arityCheck);
</ins><span class="cx"> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_create_activation);
</span><ins>+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_create_arguments);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_create_this);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_to_this);
</ins><span class="cx"> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_new_object);
</span><span class="cx"> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_new_array);
</span><span class="cx"> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_new_array_with_size);
</span><span class="cx"> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_new_array_buffer);
</span><span class="cx"> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_new_regexp);
</span><ins>+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_not);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_eq);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_neq);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_stricteq);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_nstricteq);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_less);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_lesseq);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_greater);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_greatereq);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_pre_inc);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_pre_dec);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_to_number);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_negate);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_add);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_mul);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_sub);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_div);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_mod);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_lshift);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_rshift);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_urshift);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_bitand);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_bitor);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_bitxor);
</ins><span class="cx"> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_check_has_instance);
</span><span class="cx"> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_instanceof);
</span><ins>+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_typeof);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_is_object);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_is_function);
+LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_in);
</ins><span class="cx"> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_resolve);
</span><span class="cx"> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_put_to_base);
</span><span class="cx"> LLINT_SLOW_PATH_HIDDEN_DECL(slow_path_resolve_base);
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorellintLowLevelInterpreterasm"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/llint/LowLevelInterpreter.asm (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/llint/LowLevelInterpreter.asm        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/llint/LowLevelInterpreter.asm        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -430,12 +430,12 @@
</span><span class="cx"> 
</span><span class="cx"> _llint_function_for_call_arity_check:
</span><span class="cx">     prologue(functionForCallCodeBlockGetter, functionCodeBlockSetter, _llint_entry_osr_function_for_call_arityCheck, _llint_trace_arityCheck_for_call)
</span><del>-    functionArityCheck(.functionForCallBegin, _slow_path_call_arityCheck)
</del><ins>+    functionArityCheck(.functionForCallBegin, _llint_slow_path_call_arityCheck)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_function_for_construct_arity_check:
</span><span class="cx">     prologue(functionForConstructCodeBlockGetter, functionCodeBlockSetter, _llint_entry_osr_function_for_construct_arityCheck, _llint_trace_arityCheck_for_construct)
</span><del>-    functionArityCheck(.functionForConstructBegin, _slow_path_construct_arityCheck)
</del><ins>+    functionArityCheck(.functionForConstructBegin, _llint_slow_path_construct_arityCheck)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> # Value-representation-specific code.
</span><span class="lines">@@ -473,55 +473,55 @@
</span><span class="cx"> 
</span><span class="cx"> _llint_op_less:
</span><span class="cx">     traceExecution()
</span><del>-    callSlowPath(_slow_path_less)
</del><ins>+    callSlowPath(_llint_slow_path_less)
</ins><span class="cx">     dispatch(4)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_lesseq:
</span><span class="cx">     traceExecution()
</span><del>-    callSlowPath(_slow_path_lesseq)
</del><ins>+    callSlowPath(_llint_slow_path_lesseq)
</ins><span class="cx">     dispatch(4)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_greater:
</span><span class="cx">     traceExecution()
</span><del>-    callSlowPath(_slow_path_greater)
</del><ins>+    callSlowPath(_llint_slow_path_greater)
</ins><span class="cx">     dispatch(4)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_greatereq:
</span><span class="cx">     traceExecution()
</span><del>-    callSlowPath(_slow_path_greatereq)
</del><ins>+    callSlowPath(_llint_slow_path_greatereq)
</ins><span class="cx">     dispatch(4)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_mod:
</span><span class="cx">     traceExecution()
</span><del>-    callSlowPath(_slow_path_mod)
</del><ins>+    callSlowPath(_llint_slow_path_mod)
</ins><span class="cx">     dispatch(4)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_typeof:
</span><span class="cx">     traceExecution()
</span><del>-    callSlowPath(_slow_path_typeof)
</del><ins>+    callSlowPath(_llint_slow_path_typeof)
</ins><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_is_object:
</span><span class="cx">     traceExecution()
</span><del>-    callSlowPath(_slow_path_is_object)
</del><ins>+    callSlowPath(_llint_slow_path_is_object)
</ins><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_is_function:
</span><span class="cx">     traceExecution()
</span><del>-    callSlowPath(_slow_path_is_function)
</del><ins>+    callSlowPath(_llint_slow_path_is_function)
</ins><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_in:
</span><span class="cx">     traceExecution()
</span><del>-    callSlowPath(_slow_path_in)
</del><ins>+    callSlowPath(_llint_slow_path_in)
</ins><span class="cx">     dispatch(4)
</span><span class="cx"> 
</span><span class="cx"> macro getPutToBaseOperationField(scratch, scratch1, fieldOffset, fieldGetter)
</span><span class="lines">@@ -1138,7 +1138,7 @@
</span><span class="cx"> 
</span><span class="cx"> _llint_op_strcat:
</span><span class="cx">     traceExecution()
</span><del>-    callSlowPath(_slow_path_strcat)
</del><ins>+    callSlowPath(_llint_slow_path_strcat)
</ins><span class="cx">     dispatch(4)
</span><span class="cx"> 
</span><span class="cx"> 
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorellintLowLevelInterpretercpp"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/llint/LowLevelInterpreter.cpp (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/llint/LowLevelInterpreter.cpp        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/llint/LowLevelInterpreter.cpp        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -36,7 +36,6 @@
</span><span class="cx"> #include &quot;LLIntCLoop.h&quot;
</span><span class="cx"> #include &quot;LLIntSlowPaths.h&quot;
</span><span class="cx"> #include &quot;Operations.h&quot;
</span><del>-#include &quot;SlowPaths.h&quot;
</del><span class="cx"> #include &quot;VMInspector.h&quot;
</span><span class="cx"> #include &lt;wtf/Assertions.h&gt;
</span><span class="cx"> #include &lt;wtf/MathExtras.h&gt;
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorellintLowLevelInterpreter32_64asm"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/llint/LowLevelInterpreter32_64.asm        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -364,7 +364,7 @@
</span><span class="cx">     traceExecution()
</span><span class="cx">     loadi 4[PC], t0
</span><span class="cx">     bineq TagOffset[cfr, t0, 8], EmptyValueTag, .opCreateArgumentsDone
</span><del>-    callSlowPath(_slow_path_create_arguments)
</del><ins>+    callSlowPath(_llint_slow_path_create_arguments)
</ins><span class="cx"> .opCreateArgumentsDone:
</span><span class="cx">     dispatch(2)
</span><span class="cx"> 
</span><span class="lines">@@ -383,7 +383,7 @@
</span><span class="cx">     dispatch(4)
</span><span class="cx"> 
</span><span class="cx"> .opCreateThisSlow:
</span><del>-    callSlowPath(_slow_path_create_this)
</del><ins>+    callSlowPath(_llint_slow_path_create_this)
</ins><span class="cx">     dispatch(4)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -410,7 +410,7 @@
</span><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> .opToThisSlow:
</span><del>-    callSlowPath(_slow_path_to_this)
</del><ins>+    callSlowPath(_llint_slow_path_to_this)
</ins><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -452,7 +452,7 @@
</span><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> .opNotSlow:
</span><del>-    callSlowPath(_slow_path_not)
</del><ins>+    callSlowPath(_llint_slow_path_not)
</ins><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -472,7 +472,7 @@
</span><span class="cx">     dispatch(4)
</span><span class="cx"> 
</span><span class="cx"> .opEqSlow:
</span><del>-    callSlowPath(_slow_path_eq)
</del><ins>+    callSlowPath(_llint_slow_path_eq)
</ins><span class="cx">     dispatch(4)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -519,7 +519,7 @@
</span><span class="cx">     dispatch(4)
</span><span class="cx"> 
</span><span class="cx"> .opNeqSlow:
</span><del>-    callSlowPath(_slow_path_neq)
</del><ins>+    callSlowPath(_llint_slow_path_neq)
</ins><span class="cx">     dispatch(4)
</span><span class="cx">     
</span><span class="cx"> 
</span><span class="lines">@@ -576,12 +576,12 @@
</span><span class="cx"> 
</span><span class="cx"> _llint_op_stricteq:
</span><span class="cx">     traceExecution()
</span><del>-    strictEq(macro (left, right, result) cieq left, right, result end, _slow_path_stricteq)
</del><ins>+    strictEq(macro (left, right, result) cieq left, right, result end, _llint_slow_path_stricteq)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_nstricteq:
</span><span class="cx">     traceExecution()
</span><del>-    strictEq(macro (left, right, result) cineq left, right, result end, _slow_path_nstricteq)
</del><ins>+    strictEq(macro (left, right, result) cineq left, right, result end, _llint_slow_path_nstricteq)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_inc:
</span><span class="lines">@@ -594,7 +594,7 @@
</span><span class="cx">     dispatch(2)
</span><span class="cx"> 
</span><span class="cx"> .opIncSlow:
</span><del>-    callSlowPath(_slow_path_inc)
</del><ins>+    callSlowPath(_llint_slow_path_pre_inc)
</ins><span class="cx">     dispatch(2)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -608,7 +608,7 @@
</span><span class="cx">     dispatch(2)
</span><span class="cx"> 
</span><span class="cx"> .opDecSlow:
</span><del>-    callSlowPath(_slow_path_dec)
</del><ins>+    callSlowPath(_llint_slow_path_pre_dec)
</ins><span class="cx">     dispatch(2)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -625,7 +625,7 @@
</span><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> .opToNumberSlow:
</span><del>-    callSlowPath(_slow_path_to_number)
</del><ins>+    callSlowPath(_llint_slow_path_to_number)
</ins><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -648,7 +648,7 @@
</span><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> .opNegateSlow:
</span><del>-    callSlowPath(_slow_path_negate)
</del><ins>+    callSlowPath(_llint_slow_path_negate)
</ins><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -709,7 +709,7 @@
</span><span class="cx">     binaryOp(
</span><span class="cx">         macro (left, right, slow) baddio left, right, slow end,
</span><span class="cx">         macro (left, right) addd left, right end,
</span><del>-        _slow_path_add)
</del><ins>+        _llint_slow_path_add)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_mul:
</span><span class="lines">@@ -727,7 +727,7 @@
</span><span class="cx">             storei scratch, PayloadOffset[cfr, index, 8]
</span><span class="cx">         end,
</span><span class="cx">         macro (left, right) muld left, right end,
</span><del>-        _slow_path_mul)
</del><ins>+        _llint_slow_path_mul)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_sub:
</span><span class="lines">@@ -735,7 +735,7 @@
</span><span class="cx">     binaryOp(
</span><span class="cx">         macro (left, right, slow) bsubio left, right, slow end,
</span><span class="cx">         macro (left, right) subd left, right end,
</span><del>-        _slow_path_sub)
</del><ins>+        _llint_slow_path_sub)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_div:
</span><span class="lines">@@ -754,7 +754,7 @@
</span><span class="cx">         .done:
</span><span class="cx">         end,
</span><span class="cx">         macro (left, right) divd left, right end,
</span><del>-        _slow_path_div)
</del><ins>+        _llint_slow_path_div)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> macro bitOp(operation, slowPath, advance)
</span><span class="lines">@@ -779,7 +779,7 @@
</span><span class="cx">     traceExecution()
</span><span class="cx">     bitOp(
</span><span class="cx">         macro (left, right, slow) lshifti left, right end,
</span><del>-        _slow_path_lshift,
</del><ins>+        _llint_slow_path_lshift,
</ins><span class="cx">         4)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -787,7 +787,7 @@
</span><span class="cx">     traceExecution()
</span><span class="cx">     bitOp(
</span><span class="cx">         macro (left, right, slow) rshifti left, right end,
</span><del>-        _slow_path_rshift,
</del><ins>+        _llint_slow_path_rshift,
</ins><span class="cx">         4)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -798,7 +798,7 @@
</span><span class="cx">             urshifti left, right
</span><span class="cx">             bilt right, 0, slow
</span><span class="cx">         end,
</span><del>-        _slow_path_urshift,
</del><ins>+        _llint_slow_path_urshift,
</ins><span class="cx">         4)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -806,7 +806,7 @@
</span><span class="cx">     traceExecution()
</span><span class="cx">     bitOp(
</span><span class="cx">         macro (left, right, slow) andi left, right end,
</span><del>-        _slow_path_bitand,
</del><ins>+        _llint_slow_path_bitand,
</ins><span class="cx">         5)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -814,7 +814,7 @@
</span><span class="cx">     traceExecution()
</span><span class="cx">     bitOp(
</span><span class="cx">         macro (left, right, slow) xori left, right end,
</span><del>-        _slow_path_bitxor,
</del><ins>+        _llint_slow_path_bitxor,
</ins><span class="cx">         5)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -822,7 +822,7 @@
</span><span class="cx">     traceExecution()
</span><span class="cx">     bitOp(
</span><span class="cx">         macro (left, right, slow) ori left, right end,
</span><del>-        _slow_path_bitor,
</del><ins>+        _llint_slow_path_bitor,
</ins><span class="cx">         5)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -1672,7 +1672,7 @@
</span><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> .opToPrimitiveSlowCase:
</span><del>-    callSlowPath(_slow_path_to_primitive)
</del><ins>+    callSlowPath(_llint_slow_path_to_primitive)
</ins><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> 
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCorellintLowLevelInterpreter64asm"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -247,7 +247,7 @@
</span><span class="cx">     traceExecution()
</span><span class="cx">     loadisFromInstruction(1, t0)
</span><span class="cx">     bqneq [cfr, t0, 8], ValueEmpty, .opCreateArgumentsDone
</span><del>-    callSlowPath(_slow_path_create_arguments)
</del><ins>+    callSlowPath(_llint_slow_path_create_arguments)
</ins><span class="cx"> .opCreateArgumentsDone:
</span><span class="cx">     dispatch(2)
</span><span class="cx"> 
</span><span class="lines">@@ -265,7 +265,7 @@
</span><span class="cx">     dispatch(4)
</span><span class="cx"> 
</span><span class="cx"> .opCreateThisSlow:
</span><del>-    callSlowPath(_slow_path_create_this)
</del><ins>+    callSlowPath(_llint_slow_path_create_this)
</ins><span class="cx">     dispatch(4)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -291,7 +291,7 @@
</span><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> .opToThisSlow:
</span><del>-    callSlowPath(_slow_path_to_this)
</del><ins>+    callSlowPath(_llint_slow_path_to_this)
</ins><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -331,7 +331,7 @@
</span><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> .opNotSlow:
</span><del>-    callSlowPath(_slow_path_not)
</del><ins>+    callSlowPath(_llint_slow_path_not)
</ins><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -355,13 +355,13 @@
</span><span class="cx"> _llint_op_eq:
</span><span class="cx">     equalityComparison(
</span><span class="cx">         macro (left, right, result) cieq left, right, result end,
</span><del>-        _slow_path_eq)
</del><ins>+        _llint_slow_path_eq)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_neq:
</span><span class="cx">     equalityComparison(
</span><span class="cx">         macro (left, right, result) cineq left, right, result end,
</span><del>-        _slow_path_neq)
</del><ins>+        _llint_slow_path_neq)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> macro equalNullComparison()
</span><span class="lines">@@ -430,13 +430,13 @@
</span><span class="cx"> _llint_op_stricteq:
</span><span class="cx">     strictEq(
</span><span class="cx">         macro (left, right, result) cqeq left, right, result end,
</span><del>-        _slow_path_stricteq)
</del><ins>+        _llint_slow_path_stricteq)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_nstricteq:
</span><span class="cx">     strictEq(
</span><span class="cx">         macro (left, right, result) cqneq left, right, result end,
</span><del>-        _slow_path_nstricteq)
</del><ins>+        _llint_slow_path_nstricteq)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> macro preOp(arithmeticOperation, slowPath)
</span><span class="lines">@@ -457,13 +457,13 @@
</span><span class="cx"> _llint_op_inc:
</span><span class="cx">     preOp(
</span><span class="cx">         macro (value, slow) baddio 1, value, slow end,
</span><del>-        _slow_path_inc)
</del><ins>+        _llint_slow_path_pre_inc)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_dec:
</span><span class="cx">     preOp(
</span><span class="cx">         macro (value, slow) bsubio 1, value, slow end,
</span><del>-        _slow_path_dec)
</del><ins>+        _llint_slow_path_pre_dec)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_to_number:
</span><span class="lines">@@ -478,7 +478,7 @@
</span><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> .opToNumberSlow:
</span><del>-    callSlowPath(_slow_path_to_number)
</del><ins>+    callSlowPath(_llint_slow_path_to_number)
</ins><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -500,7 +500,7 @@
</span><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> .opNegateSlow:
</span><del>-    callSlowPath(_slow_path_negate)
</del><ins>+    callSlowPath(_llint_slow_path_negate)
</ins><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -568,7 +568,7 @@
</span><span class="cx">     binaryOp(
</span><span class="cx">         macro (left, right, slow) baddio left, right, slow end,
</span><span class="cx">         macro (left, right) addd left, right end,
</span><del>-        _slow_path_add)
</del><ins>+        _llint_slow_path_add)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_mul:
</span><span class="lines">@@ -586,7 +586,7 @@
</span><span class="cx">             storeq t3, [cfr, index, 8]
</span><span class="cx">         end,
</span><span class="cx">         macro (left, right) muld left, right end,
</span><del>-        _slow_path_mul)
</del><ins>+        _llint_slow_path_mul)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_sub:
</span><span class="lines">@@ -594,7 +594,7 @@
</span><span class="cx">     binaryOp(
</span><span class="cx">         macro (left, right, slow) bsubio left, right, slow end,
</span><span class="cx">         macro (left, right) subd left, right end,
</span><del>-        _slow_path_sub)
</del><ins>+        _llint_slow_path_sub)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> _llint_op_div:
</span><span class="lines">@@ -618,7 +618,7 @@
</span><span class="cx">             storeq t0, [cfr, index, 8]
</span><span class="cx">         end,
</span><span class="cx">         macro (left, right) divd left, right end,
</span><del>-        _slow_path_div)
</del><ins>+        _llint_slow_path_div)
</ins><span class="cx"> 
</span><span class="cx"> 
</span><span class="cx"> macro bitOp(operation, slowPath, advance)
</span><span class="lines">@@ -643,7 +643,7 @@
</span><span class="cx">     traceExecution()
</span><span class="cx">     bitOp(
</span><span class="cx">         macro (left, right, slow) lshifti left, right end,
</span><del>-        _slow_path_lshift,
</del><ins>+        _llint_slow_path_lshift,
</ins><span class="cx">         4)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -651,7 +651,7 @@
</span><span class="cx">     traceExecution()
</span><span class="cx">     bitOp(
</span><span class="cx">         macro (left, right, slow) rshifti left, right end,
</span><del>-        _slow_path_rshift,
</del><ins>+        _llint_slow_path_rshift,
</ins><span class="cx">         4)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -662,7 +662,7 @@
</span><span class="cx">             urshifti left, right
</span><span class="cx">             bilt right, 0, slow
</span><span class="cx">         end,
</span><del>-        _slow_path_urshift,
</del><ins>+        _llint_slow_path_urshift,
</ins><span class="cx">         4)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -670,7 +670,7 @@
</span><span class="cx">     traceExecution()
</span><span class="cx">     bitOp(
</span><span class="cx">         macro (left, right, slow) andi left, right end,
</span><del>-        _slow_path_bitand,
</del><ins>+        _llint_slow_path_bitand,
</ins><span class="cx">         5)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -678,7 +678,7 @@
</span><span class="cx">     traceExecution()
</span><span class="cx">     bitOp(
</span><span class="cx">         macro (left, right, slow) xori left, right end,
</span><del>-        _slow_path_bitxor,
</del><ins>+        _llint_slow_path_bitxor,
</ins><span class="cx">         5)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -686,7 +686,7 @@
</span><span class="cx">     traceExecution()
</span><span class="cx">     bitOp(
</span><span class="cx">         macro (left, right, slow) ori left, right end,
</span><del>-        _slow_path_bitor,
</del><ins>+        _llint_slow_path_bitor,
</ins><span class="cx">         5)
</span><span class="cx"> 
</span><span class="cx"> 
</span><span class="lines">@@ -1505,7 +1505,7 @@
</span><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> .opToPrimitiveSlowCase:
</span><del>-    callSlowPath(_slow_path_to_primitive)
</del><ins>+    callSlowPath(_llint_slow_path_to_primitive)
</ins><span class="cx">     dispatch(3)
</span><span class="cx"> 
</span><span class="cx"> 
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCoreruntimeCommonSlowPathscpp"></a>
<div class="delfile"><h4>Deleted: branches/dfgFourthTier/Source/JavaScriptCore/runtime/CommonSlowPaths.cpp (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/runtime/CommonSlowPaths.cpp        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/runtime/CommonSlowPaths.cpp        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -1,473 +0,0 @@
</span><del>-/*
- * Copyright (C) 2011, 2012, 2013 Apple Inc. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
- */
-
-#include &quot;config.h&quot;
-#include &quot;CommonSlowPaths.h&quot;
-
-#if ENABLE(JIT) || ENABLE(LLINT)
-
-#include &quot;Arguments.h&quot;
-#include &quot;ArrayConstructor.h&quot;
-#include &quot;CallFrame.h&quot;
-#include &quot;CodeProfiling.h&quot;
-#include &quot;GetterSetter.h&quot;
-#include &quot;HostCallReturnValue.h&quot;
-#include &quot;Interpreter.h&quot;
-#include &quot;JIT.h&quot;
-#include &quot;JITDriver.h&quot;
-#include &quot;JITStubs.h&quot;
-#include &quot;JSActivation.h&quot;
-#include &quot;JSCJSValue.h&quot;
-#include &quot;JSGlobalObjectFunctions.h&quot;
-#include &quot;JSNameScope.h&quot;
-#include &quot;JSPropertyNameIterator.h&quot;
-#include &quot;JSString.h&quot;
-#include &quot;JSWithScope.h&quot;
-#include &quot;LLIntCommon.h&quot;
-#include &quot;LLIntExceptions.h&quot;
-#include &quot;LowLevelInterpreter.h&quot;
-#include &quot;ObjectConstructor.h&quot;
-#include &quot;Operations.h&quot;
-#include &quot;StructureRareDataInlines.h&quot;
-#include &lt;wtf/StringPrintStream.h&gt;
-
-namespace JSC {
-
-#define BEGIN_NO_SET_PC() \
-    VM&amp; vm = exec-&gt;vm();      \
-    NativeCallFrameTracer tracer(&amp;vm, exec)
-
-#ifndef NDEBUG
-#define SET_PC_FOR_STUBS() do { \
-        exec-&gt;codeBlock()-&gt;bytecodeOffset(pc); \
-        exec-&gt;setCurrentVPC(pc + 1); \
-    } while (false)
-#else
-#define SET_PC_FOR_STUBS() do { \
-        exec-&gt;setCurrentVPC(pc + 1); \
-    } while (false)
-#endif
-
-#define BEGIN()                           \
-    BEGIN_NO_SET_PC();                    \
-    SET_PC_FOR_STUBS()
-
-#define OP(index) (exec-&gt;uncheckedR(pc[index].u.operand))
-#define OP_C(index) (exec-&gt;r(pc[index].u.operand))
-
-#define RETURN_TWO(first, second) do {       \
-        return encodeResult(first, second);        \
-    } while (false)
-
-#define END_IMPL() RETURN_TWO(pc, exec)
-
-#define THROW(exceptionToThrow) do {                        \
-        vm.exception = (exceptionToThrow);                \
-        pc = LLInt::returnToThrow(exec, pc);                             \
-        END_IMPL();                                         \
-    } while (false)
-
-#define CHECK_EXCEPTION() do {                    \
-        if (UNLIKELY(vm.exception)) {           \
-            pc = LLInt::returnToThrow(exec, pc);               \
-            END_IMPL();                           \
-        }                                               \
-    } while (false)
-
-#define END() do {                        \
-        CHECK_EXCEPTION();                \
-        END_IMPL();                       \
-    } while (false)
-
-#define BRANCH(opcode, condition) do {                      \
-        bool bCondition = (condition);                         \
-        CHECK_EXCEPTION();                                  \
-        if (bCondition)                                        \
-            pc += pc[OPCODE_LENGTH(opcode) - 1].u.operand;        \
-        else                                                      \
-            pc += OPCODE_LENGTH(opcode);                          \
-        END_IMPL();                                         \
-    } while (false)
-
-#define RETURN(value) do {                \
-        JSValue rReturnValue = (value);      \
-        CHECK_EXCEPTION();                \
-        OP(1) = rReturnValue;          \
-        END_IMPL();                       \
-    } while (false)
-
-#if ENABLE(VALUE_PROFILER)
-#define RETURN_PROFILED(opcode, value) do {               \
-        JSValue rpPeturnValue = (value);                     \
-        CHECK_EXCEPTION();                                \
-        OP(1) = rpPeturnValue;                         \
-        PROFILE_VALUE(opcode, rpPeturnValue);          \
-        END_IMPL();                                       \
-    } while (false)
-
-#define PROFILE_VALUE(opcode, value) do { \
-        pc[OPCODE_LENGTH(opcode) - 1].u.profile-&gt;m_buckets[0] = \
-        JSValue::encode(value);                  \
-    } while (false)
-
-#else // ENABLE(VALUE_PROFILER)
-#define RETURN_PROFILED(opcode, value) RETURN(value)
-
-#define PROFILE_VALUE(opcode, value) do { } while (false)
-
-#endif // ENABLE(VALUE_PROFILER)
-
-#define CALL_END_IMPL(exec, callTarget) RETURN_TWO((callTarget), (exec))
-
-#define CALL_THROW(exec, pc, exceptionToThrow) do {               \
-        ExecState* ctExec = (exec);                                  \
-        Instruction* ctPC = (pc);                                    \
-        vm.exception = (exceptionToThrow);                      \
-        CALL_END_IMPL(ctExec, LLInt::callToThrow(ctExec, ctPC)); \
-    } while (false)
-
-#define CALL_CHECK_EXCEPTION(exec, pc) do {                       \
-        ExecState* cceExec = (exec);                                 \
-        Instruction* ccePC = (pc);                                   \
-        if (UNLIKELY(vm.exception))                              \
-            CALL_END_IMPL(cceExec, LLInt::callToThrow(cceExec, ccePC)); \
-    } while (false)
-
-#define CALL_RETURN(exec, pc, callTarget) do {                    \
-        ExecState* crExec = (exec);                                  \
-        Instruction* crPC = (pc);                                    \
-        void* crCallTarget = (callTarget);                           \
-        CALL_CHECK_EXCEPTION(crExec-&gt;callerFrame(), crPC);  \
-        CALL_END_IMPL(crExec, crCallTarget);                \
-    } while (false)
-
-SLOW_PATH_DECL(slow_path_call_arityCheck)
-{
-    BEGIN();
-    ExecState* newExec = CommonSlowPaths::arityCheckFor(exec, &amp;vm.interpreter-&gt;stack(), CodeForCall);
-    if (!newExec) {
-        ReturnAddressPtr returnPC = exec-&gt;returnPC();
-        exec = exec-&gt;callerFrame();
-        vm.exception = createStackOverflowError(exec);
-        LLInt::interpreterThrowInCaller(exec, returnPC);
-        RETURN_TWO(bitwise_cast&lt;void*&gt;(static_cast&lt;uintptr_t&gt;(1)), exec);
-    }
-    RETURN_TWO(0, newExec);
-}
-
-SLOW_PATH_DECL(slow_path_construct_arityCheck)
-{
-    BEGIN();
-    ExecState* newExec = CommonSlowPaths::arityCheckFor(exec, &amp;vm.interpreter-&gt;stack(), CodeForConstruct);
-    if (!newExec) {
-        ReturnAddressPtr returnPC = exec-&gt;returnPC();
-        exec = exec-&gt;callerFrame();
-        vm.exception = createStackOverflowError(exec);
-        LLInt::interpreterThrowInCaller(exec, returnPC);
-        RETURN_TWO(bitwise_cast&lt;void*&gt;(static_cast&lt;uintptr_t&gt;(1)), exec);
-    }
-    RETURN_TWO(0, newExec);
-}
-
-SLOW_PATH_DECL(slow_path_create_arguments)
-{
-    BEGIN();
-    JSValue arguments = JSValue(Arguments::create(vm, exec));
-    CHECK_EXCEPTION();
-    exec-&gt;uncheckedR(pc[1].u.operand) = arguments;
-    exec-&gt;uncheckedR(unmodifiedArgumentsRegister(pc[1].u.operand)) = arguments;
-    END();
-}
-
-SLOW_PATH_DECL(slow_path_create_this)
-{
-    BEGIN();
-    JSFunction* constructor = jsCast&lt;JSFunction*&gt;(OP(2).jsValue().asCell());
-    
-#if !ASSERT_DISABLED
-    ConstructData constructData;
-    ASSERT(constructor-&gt;methodTable()-&gt;getConstructData(constructor, constructData) == ConstructTypeJS);
-#endif
-
-    size_t inlineCapacity = pc[3].u.operand;
-    Structure* structure = constructor-&gt;allocationProfile(exec, inlineCapacity)-&gt;structure();
-    RETURN(constructEmptyObject(exec, structure));
-}
-
-SLOW_PATH_DECL(slow_path_to_this)
-{
-    BEGIN();
-    JSValue v1 = OP(1).jsValue();
-#if ENABLE(VALUE_PROFILER)
-    pc[OPCODE_LENGTH(op_to_this) - 1].u.profile-&gt;m_buckets[0] =
-        JSValue::encode(v1.structureOrUndefined());
-#endif
-    RETURN(v1.toThis(exec, exec-&gt;codeBlock()-&gt;isStrictMode() ? StrictMode : NotStrictMode));
-}
-
-SLOW_PATH_DECL(slow_path_not)
-{
-    BEGIN();
-    RETURN(jsBoolean(!OP_C(2).jsValue().toBoolean(exec)));
-}
-
-SLOW_PATH_DECL(slow_path_eq)
-{
-    BEGIN();
-    RETURN(jsBoolean(JSValue::equal(exec, OP_C(2).jsValue(), OP_C(3).jsValue())));
-}
-
-SLOW_PATH_DECL(slow_path_neq)
-{
-    BEGIN();
-    RETURN(jsBoolean(!JSValue::equal(exec, OP_C(2).jsValue(), OP_C(3).jsValue())));
-}
-
-SLOW_PATH_DECL(slow_path_stricteq)
-{
-    BEGIN();
-    RETURN(jsBoolean(JSValue::strictEqual(exec, OP_C(2).jsValue(), OP_C(3).jsValue())));
-}
-
-SLOW_PATH_DECL(slow_path_nstricteq)
-{
-    BEGIN();
-    RETURN(jsBoolean(!JSValue::strictEqual(exec, OP_C(2).jsValue(), OP_C(3).jsValue())));
-}
-
-SLOW_PATH_DECL(slow_path_less)
-{
-    BEGIN();
-    RETURN(jsBoolean(jsLess&lt;true&gt;(exec, OP_C(2).jsValue(), OP_C(3).jsValue())));
-}
-
-SLOW_PATH_DECL(slow_path_lesseq)
-{
-    BEGIN();
-    RETURN(jsBoolean(jsLessEq&lt;true&gt;(exec, OP_C(2).jsValue(), OP_C(3).jsValue())));
-}
-
-SLOW_PATH_DECL(slow_path_greater)
-{
-    BEGIN();
-    RETURN(jsBoolean(jsLess&lt;false&gt;(exec, OP_C(3).jsValue(), OP_C(2).jsValue())));
-}
-
-SLOW_PATH_DECL(slow_path_greatereq)
-{
-    BEGIN();
-    RETURN(jsBoolean(jsLessEq&lt;false&gt;(exec, OP_C(3).jsValue(), OP_C(2).jsValue())));
-}
-
-SLOW_PATH_DECL(slow_path_inc)
-{
-    BEGIN();
-    RETURN(jsNumber(OP(1).jsValue().toNumber(exec) + 1));
-}
-
-SLOW_PATH_DECL(slow_path_dec)
-{
-    BEGIN();
-    RETURN(jsNumber(OP(1).jsValue().toNumber(exec) - 1));
-}
-
-SLOW_PATH_DECL(slow_path_to_number)
-{
-    BEGIN();
-    RETURN(jsNumber(OP_C(2).jsValue().toNumber(exec)));
-}
-
-SLOW_PATH_DECL(slow_path_negate)
-{
-    BEGIN();
-    RETURN(jsNumber(-OP_C(2).jsValue().toNumber(exec)));
-}
-
-SLOW_PATH_DECL(slow_path_add)
-{
-    BEGIN();
-    JSValue v1 = OP_C(2).jsValue();
-    JSValue v2 = OP_C(3).jsValue();
-    
-    if (v1.isString() &amp;&amp; !v2.isObject())
-        RETURN(jsString(exec, asString(v1), v2.toString(exec)));
-    
-    if (v1.isNumber() &amp;&amp; v2.isNumber())
-        RETURN(jsNumber(v1.asNumber() + v2.asNumber()));
-    
-    RETURN(jsAddSlowCase(exec, v1, v2));
-}
-
-// The following arithmetic and bitwise operations need to be sure to run
-// toNumber() on their operands in order.  (A call to toNumber() is idempotent
-// if an exception is already set on the ExecState.)
-
-SLOW_PATH_DECL(slow_path_mul)
-{
-    BEGIN();
-    double a = OP_C(2).jsValue().toNumber(exec);
-    double b = OP_C(3).jsValue().toNumber(exec);
-    RETURN(jsNumber(a * b));
-}
-
-SLOW_PATH_DECL(slow_path_sub)
-{
-    BEGIN();
-    double a = OP_C(2).jsValue().toNumber(exec);
-    double b = OP_C(3).jsValue().toNumber(exec);
-    RETURN(jsNumber(a - b));
-}
-
-SLOW_PATH_DECL(slow_path_div)
-{
-    BEGIN();
-    double a = OP_C(2).jsValue().toNumber(exec);
-    double b = OP_C(3).jsValue().toNumber(exec);
-    RETURN(jsNumber(a / b));
-}
-
-SLOW_PATH_DECL(slow_path_mod)
-{
-    BEGIN();
-    double a = OP_C(2).jsValue().toNumber(exec);
-    double b = OP_C(3).jsValue().toNumber(exec);
-    RETURN(jsNumber(fmod(a, b)));
-}
-
-SLOW_PATH_DECL(slow_path_lshift)
-{
-    BEGIN();
-    int32_t a = OP_C(2).jsValue().toInt32(exec);
-    uint32_t b = OP_C(3).jsValue().toUInt32(exec);
-    RETURN(jsNumber(a &lt;&lt; (b &amp; 31)));
-}
-
-SLOW_PATH_DECL(slow_path_rshift)
-{
-    BEGIN();
-    int32_t a = OP_C(2).jsValue().toInt32(exec);
-    uint32_t b = OP_C(3).jsValue().toUInt32(exec);
-    RETURN(jsNumber(a &gt;&gt; (b &amp; 31)));
-}
-
-SLOW_PATH_DECL(slow_path_urshift)
-{
-    BEGIN();
-    uint32_t a = OP_C(2).jsValue().toUInt32(exec);
-    uint32_t b = OP_C(3).jsValue().toUInt32(exec);
-    RETURN(jsNumber(a &gt;&gt; (b &amp; 31)));
-}
-
-SLOW_PATH_DECL(slow_path_bitand)
-{
-    BEGIN();
-    int32_t a = OP_C(2).jsValue().toInt32(exec);
-    int32_t b = OP_C(3).jsValue().toInt32(exec);
-    RETURN(jsNumber(a &amp; b));
-}
-
-SLOW_PATH_DECL(slow_path_bitor)
-{
-    BEGIN();
-    int32_t a = OP_C(2).jsValue().toInt32(exec);
-    int32_t b = OP_C(3).jsValue().toInt32(exec);
-    RETURN(jsNumber(a | b));
-}
-
-SLOW_PATH_DECL(slow_path_bitxor)
-{
-    BEGIN();
-    int32_t a = OP_C(2).jsValue().toInt32(exec);
-    int32_t b = OP_C(3).jsValue().toInt32(exec);
-    RETURN(jsNumber(a ^ b));
-}
-
-SLOW_PATH_DECL(slow_path_typeof)
-{
-    BEGIN();
-    RETURN(jsTypeStringForValue(exec, OP_C(2).jsValue()));
-}
-
-SLOW_PATH_DECL(slow_path_is_object)
-{
-    BEGIN();
-    RETURN(jsBoolean(jsIsObjectType(exec, OP_C(2).jsValue())));
-}
-
-SLOW_PATH_DECL(slow_path_is_function)
-{
-    BEGIN();
-    RETURN(jsBoolean(jsIsFunctionType(OP_C(2).jsValue())));
-}
-
-SLOW_PATH_DECL(slow_path_in)
-{
-    BEGIN();
-    RETURN(jsBoolean(CommonSlowPaths::opIn(exec, OP_C(2).jsValue(), OP_C(3).jsValue())));
-}
-
-SLOW_PATH_DECL(slow_path_del_by_val)
-{
-    BEGIN();
-    JSValue baseValue = OP_C(2).jsValue();
-    JSObject* baseObject = baseValue.toObject(exec);
-    
-    JSValue subscript = OP_C(3).jsValue();
-    
-    bool couldDelete;
-    
-    uint32_t i;
-    if (subscript.getUInt32(i))
-        couldDelete = baseObject-&gt;methodTable()-&gt;deletePropertyByIndex(baseObject, exec, i);
-    else if (isName(subscript))
-        couldDelete = baseObject-&gt;methodTable()-&gt;deleteProperty(baseObject, exec, jsCast&lt;NameInstance*&gt;(subscript.asCell())-&gt;privateName());
-    else {
-        CHECK_EXCEPTION();
-        Identifier property(exec, subscript.toString(exec)-&gt;value(exec));
-        CHECK_EXCEPTION();
-        couldDelete = baseObject-&gt;methodTable()-&gt;deleteProperty(baseObject, exec, property);
-    }
-    
-    if (!couldDelete &amp;&amp; exec-&gt;codeBlock()-&gt;isStrictMode())
-        THROW(createTypeError(exec, &quot;Unable to delete property.&quot;));
-    
-    RETURN(jsBoolean(couldDelete));
-}
-
-SLOW_PATH_DECL(slow_path_strcat)
-{
-    BEGIN();
-    RETURN(jsString(exec, &amp;OP(2), pc[3].u.operand));
-}
-
-SLOW_PATH_DECL(slow_path_to_primitive)
-{
-    BEGIN();
-    RETURN(OP_C(2).jsValue().toPrimitive(exec));
-}
-
-} // namespace JSC
-
-#endif // ENABLE(JIT) || ENABLE(LLINT)
</del></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCoreruntimeCommonSlowPathsh"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/runtime/CommonSlowPaths.h (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/runtime/CommonSlowPaths.h        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/runtime/CommonSlowPaths.h        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -1,5 +1,5 @@
</span><span class="cx"> /*
</span><del>- * Copyright (C) 2011, 2012, 2013 Apple Inc. All rights reserved.
</del><ins>+ * Copyright (C) 2011, 2012 Apple Inc. All rights reserved.
</ins><span class="cx">  *
</span><span class="cx">  * Redistribution and use in source and binary forms, with or without
</span><span class="cx">  * modification, are permitted provided that the following conditions
</span><span class="lines">@@ -29,11 +29,9 @@
</span><span class="cx"> #include &quot;CodeBlock.h&quot;
</span><span class="cx"> #include &quot;CodeSpecializationKind.h&quot;
</span><span class="cx"> #include &quot;ExceptionHelpers.h&quot;
</span><ins>+#include &quot;JSArray.h&quot;
</ins><span class="cx"> #include &quot;NameInstance.h&quot;
</span><del>-#include &lt;wtf/Platform.h&gt;
</del><span class="cx"> 
</span><del>-#if ENABLE(JIT) || ENABLE(LLINT)
-
</del><span class="cx"> namespace JSC {
</span><span class="cx"> 
</span><span class="cx"> // The purpose of this namespace is to include slow paths that are shared
</span><span class="lines">@@ -99,109 +97,6 @@
</span><span class="cx">     return baseObj-&gt;hasProperty(exec, property);
</span><span class="cx"> }
</span><span class="cx"> 
</span><del>-} // namespace CommonSlowPaths
</del><ins>+} } // namespace JSC::CommonSlowPaths
</ins><span class="cx"> 
</span><del>-class ExecState;
-struct Instruction;
-
-#if USE(JSVALUE64)
-// According to C++ rules, a type used for the return signature of function with C linkage (i.e.
-// 'extern &quot;C&quot;') needs to be POD; hence putting any constructors into it could cause either compiler
-// warnings, or worse, a change in the ABI used to return these types.
-struct SlowPathReturnType {
-    void* a;
-    ExecState* b;
-};
-
-inline SlowPathReturnType encodeResult(void* a, ExecState* b)
-{
-    SlowPathReturnType result;
-    result.a = a;
-    result.b = b;
-    return result;
-}
-
-inline void decodeResult(SlowPathReturnType result, void*&amp; a, ExecState*&amp; b)
-{
-    a = result.a;
-    b = result.b;
-}
-
-#else // USE(JSVALUE32_64)
-typedef int64_t SlowPathReturnType;
-
-typedef union {
-    struct {
-        void* a;
-        ExecState* b;
-    } pair;
-    int64_t i;
-} SlowPathReturnTypeEncoding;
-
-inline SlowPathReturnType encodeResult(void* a, ExecState* b)
-{
-    SlowPathReturnTypeEncoding u;
-    u.pair.a = a;
-    u.pair.b = b;
-    return u.i;
-}
-
-inline void decodeResult(SlowPathReturnType result, void*&amp; a, ExecState*&amp; b)
-{
-    SlowPathReturnTypeEncoding u;
-    u.i = result;
-    a = u.pair.a;
-    b = u.pair.b;
-}
-#endif // USE(JSVALUE32_64)
-    
-#define SLOW_PATH
-    
-#define SLOW_PATH_DECL(name) \
-extern &quot;C&quot; SlowPathReturnType SLOW_PATH name(ExecState* exec, Instruction* pc)
-    
-#define SLOW_PATH_HIDDEN_DECL(name) \
-SLOW_PATH_DECL(name) WTF_INTERNAL
-    
-SLOW_PATH_HIDDEN_DECL(slow_path_call_arityCheck);
-SLOW_PATH_HIDDEN_DECL(slow_path_construct_arityCheck);
-SLOW_PATH_HIDDEN_DECL(slow_path_create_arguments);
-SLOW_PATH_HIDDEN_DECL(slow_path_create_this);
-SLOW_PATH_HIDDEN_DECL(slow_path_to_this);
-SLOW_PATH_HIDDEN_DECL(slow_path_not);
-SLOW_PATH_HIDDEN_DECL(slow_path_eq);
-SLOW_PATH_HIDDEN_DECL(slow_path_neq);
-SLOW_PATH_HIDDEN_DECL(slow_path_stricteq);
-SLOW_PATH_HIDDEN_DECL(slow_path_nstricteq);
-SLOW_PATH_HIDDEN_DECL(slow_path_less);
-SLOW_PATH_HIDDEN_DECL(slow_path_lesseq);
-SLOW_PATH_HIDDEN_DECL(slow_path_greater);
-SLOW_PATH_HIDDEN_DECL(slow_path_greatereq);
-SLOW_PATH_HIDDEN_DECL(slow_path_inc);
-SLOW_PATH_HIDDEN_DECL(slow_path_dec);
-SLOW_PATH_HIDDEN_DECL(slow_path_to_number);
-SLOW_PATH_HIDDEN_DECL(slow_path_negate);
-SLOW_PATH_HIDDEN_DECL(slow_path_add);
-SLOW_PATH_HIDDEN_DECL(slow_path_mul);
-SLOW_PATH_HIDDEN_DECL(slow_path_sub);
-SLOW_PATH_HIDDEN_DECL(slow_path_div);
-SLOW_PATH_HIDDEN_DECL(slow_path_mod);
-SLOW_PATH_HIDDEN_DECL(slow_path_lshift);
-SLOW_PATH_HIDDEN_DECL(slow_path_rshift);
-SLOW_PATH_HIDDEN_DECL(slow_path_urshift);
-SLOW_PATH_HIDDEN_DECL(slow_path_bitand);
-SLOW_PATH_HIDDEN_DECL(slow_path_bitor);
-SLOW_PATH_HIDDEN_DECL(slow_path_bitxor);
-SLOW_PATH_HIDDEN_DECL(slow_path_typeof);
-SLOW_PATH_HIDDEN_DECL(slow_path_is_object);
-SLOW_PATH_HIDDEN_DECL(slow_path_is_function);
-SLOW_PATH_HIDDEN_DECL(slow_path_in);
-SLOW_PATH_HIDDEN_DECL(slow_path_del_by_val);
-SLOW_PATH_HIDDEN_DECL(slow_path_strcat);
-SLOW_PATH_HIDDEN_DECL(slow_path_to_primitive);
-
-} // namespace JSC
-
-#endif // ENABLE(JIT) || ENABLE(LLINT)
-
</del><span class="cx"> #endif // CommonSlowPaths_h
</span></span></pre></div>
<a id="branchesdfgFourthTierSourceJavaScriptCoreruntimeJSCJSValueh"></a>
<div class="modfile"><h4>Modified: branches/dfgFourthTier/Source/JavaScriptCore/runtime/JSCJSValue.h (151344 => 151345)</h4>
<pre class="diff"><span>
<span class="info">--- branches/dfgFourthTier/Source/JavaScriptCore/runtime/JSCJSValue.h        2013-06-08 00:11:34 UTC (rev 151344)
+++ branches/dfgFourthTier/Source/JavaScriptCore/runtime/JSCJSValue.h        2013-06-08 02:11:54 UTC (rev 151345)
</span><span class="lines">@@ -111,7 +111,6 @@
</span><span class="cx"> class JSValue {
</span><span class="cx">     friend struct EncodedJSValueHashTraits;
</span><span class="cx">     friend class JIT;
</span><del>-    friend class JITSlowPathCall;
</del><span class="cx">     friend class JITStubs;
</span><span class="cx">     friend class JITStubCall;
</span><span class="cx">     friend class JSInterfaceJIT;
</span></span></pre>
</div>
</div>

</body>
</html>