<!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>[192665] trunk/Source/JavaScriptCore</title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/192665">192665</a></dd>
<dt>Author</dt> <dd>fpizlo@apple.com</dd>
<dt>Date</dt> <dd>2015-11-19 15:35:50 -0800 (Thu, 19 Nov 2015)</dd>
</dl>
<h3>Log Message</h3>
<pre>B3 should have a story for Ext/Trunc strength reduction
https://bugs.webkit.org/show_bug.cgi?id=151464
Reviewed by Geoffrey Garen.
The LLVM shift operations require the shift amount to have the same type as the shift base. The B3
shift operations require the shift amount to be an Int32. DFG concurs with this. But the initial
lowering should involve pretending the FTLOutput's shift operations still take an LLVM-style shift
amount so that we don't regress FTL->LLVM performance. That means emitting an extra Trunc. That means
that we want to be able to constant fold Trunc and be able to fold Trunc(ZExt).
* b3/B3LowerToAir.cpp:
(JSC::B3::Air::LowerToAir::lower):
* b3/B3ReduceStrength.cpp:
* b3/air/AirOpcode.opcodes:
* b3/testb3.cpp:
(JSC::B3::testSwitchChillDiv):
(JSC::B3::testTruncFold):
(JSC::B3::testZExt32):
(JSC::B3::testZExt32Fold):
(JSC::B3::testSExt32):
(JSC::B3::testSExt32Fold):
(JSC::B3::testTruncZExt32):
(JSC::B3::testTruncSExt32):
(JSC::B3::zero):
(JSC::B3::run):
* ftl/FTLB3Output.cpp:
(JSC::FTL::Output::store):
(JSC::FTL::Output::baseIndex):
(JSC::FTL::Output::branch):
* ftl/FTLB3Output.h:
(JSC::FTL::Output::bitAnd):
(JSC::FTL::Output::bitOr):
(JSC::FTL::Output::bitXor):
(JSC::FTL::Output::shl):
(JSC::FTL::Output::aShr):
(JSC::FTL::Output::lShr):
(JSC::FTL::Output::bitNot):
(JSC::FTL::Output::insertElement):
(JSC::FTL::Output::address):
(JSC::FTL::Output::baseIndex):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3LowerToAircpp">trunk/Source/JavaScriptCore/b3/B3LowerToAir.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3ReduceStrengthcpp">trunk/Source/JavaScriptCore/b3/B3ReduceStrength.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3airAirOpcodeopcodes">trunk/Source/JavaScriptCore/b3/air/AirOpcode.opcodes</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3testb3cpp">trunk/Source/JavaScriptCore/b3/testb3.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLB3Outputcpp">trunk/Source/JavaScriptCore/ftl/FTLB3Output.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLB3Outputh">trunk/Source/JavaScriptCore/ftl/FTLB3Output.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (192664 => 192665)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog        2015-11-19 23:32:09 UTC (rev 192664)
+++ trunk/Source/JavaScriptCore/ChangeLog        2015-11-19 23:35:50 UTC (rev 192665)
</span><span class="lines">@@ -1,3 +1,47 @@
</span><ins>+2015-11-19 Filip Pizlo <fpizlo@apple.com>
+
+ B3 should have a story for Ext/Trunc strength reduction
+ https://bugs.webkit.org/show_bug.cgi?id=151464
+
+ Reviewed by Geoffrey Garen.
+
+ The LLVM shift operations require the shift amount to have the same type as the shift base. The B3
+ shift operations require the shift amount to be an Int32. DFG concurs with this. But the initial
+ lowering should involve pretending the FTLOutput's shift operations still take an LLVM-style shift
+ amount so that we don't regress FTL->LLVM performance. That means emitting an extra Trunc. That means
+ that we want to be able to constant fold Trunc and be able to fold Trunc(ZExt).
+
+ * b3/B3LowerToAir.cpp:
+ (JSC::B3::Air::LowerToAir::lower):
+ * b3/B3ReduceStrength.cpp:
+ * b3/air/AirOpcode.opcodes:
+ * b3/testb3.cpp:
+ (JSC::B3::testSwitchChillDiv):
+ (JSC::B3::testTruncFold):
+ (JSC::B3::testZExt32):
+ (JSC::B3::testZExt32Fold):
+ (JSC::B3::testSExt32):
+ (JSC::B3::testSExt32Fold):
+ (JSC::B3::testTruncZExt32):
+ (JSC::B3::testTruncSExt32):
+ (JSC::B3::zero):
+ (JSC::B3::run):
+ * ftl/FTLB3Output.cpp:
+ (JSC::FTL::Output::store):
+ (JSC::FTL::Output::baseIndex):
+ (JSC::FTL::Output::branch):
+ * ftl/FTLB3Output.h:
+ (JSC::FTL::Output::bitAnd):
+ (JSC::FTL::Output::bitOr):
+ (JSC::FTL::Output::bitXor):
+ (JSC::FTL::Output::shl):
+ (JSC::FTL::Output::aShr):
+ (JSC::FTL::Output::lShr):
+ (JSC::FTL::Output::bitNot):
+ (JSC::FTL::Output::insertElement):
+ (JSC::FTL::Output::address):
+ (JSC::FTL::Output::baseIndex):
+
</ins><span class="cx"> 2015-11-19 Mark Lam <mark.lam@apple.com>
</span><span class="cx">
</span><span class="cx"> Create correctness tests for binary snippet operators.
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3LowerToAircpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3LowerToAir.cpp (192664 => 192665)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3LowerToAir.cpp        2015-11-19 23:32:09 UTC (rev 192664)
+++ trunk/Source/JavaScriptCore/b3/B3LowerToAir.cpp        2015-11-19 23:35:50 UTC (rev 192665)
</span><span class="lines">@@ -1398,6 +1398,11 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ case SExt32: {
+ append(SignExtend32ToPtr, tmp(m_value->child(0)), tmp(m_value));
+ return;
+ }
+
</ins><span class="cx"> case ArgumentReg: {
</span><span class="cx"> m_prologue.append(Inst(
</span><span class="cx"> moveForType(m_value->type()), m_value,
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3ReduceStrengthcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3ReduceStrength.cpp (192664 => 192665)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3ReduceStrength.cpp        2015-11-19 23:32:09 UTC (rev 192664)
+++ trunk/Source/JavaScriptCore/b3/B3ReduceStrength.cpp        2015-11-19 23:35:50 UTC (rev 192665)
</span><span class="lines">@@ -326,6 +326,16 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ // Turn this: BitAnd(64-bit value, 32 ones)
+ // Into this: ZExt32(Trunc(64-bit value))
+ if (m_value->child(1)->isInt64(0xffffffffllu)) {
+ Value* newValue = m_insertionSet.insert<Value>(
+ m_index, ZExt32, m_value->origin(),
+ m_insertionSet.insert<Value>(m_index, Trunc, m_value->origin(), m_value->child(0)));
+ m_value->replaceWithIdentity(newValue);
+ m_changed = true;
+ break;
+ }
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case BitOr:
</span><span class="lines">@@ -479,9 +489,47 @@
</span><span class="cx"> m_changed = true;
</span><span class="cx"> break;
</span><span class="cx"> }
</span><ins>+ break;
</ins><span class="cx">
</span><ins>+ case SExt32:
+ // Turn this: SExt32(constant)
+ // Into this: static_cast<int64_t>(constant)
+ if (m_value->child(0)->hasInt32()) {
+ replaceWithNewValue(m_proc.addIntConstant(m_value, m_value->child(0)->asInt32()));
+ break;
+ }
</ins><span class="cx"> break;
</span><span class="cx">
</span><ins>+ case ZExt32:
+ // Turn this: ZExt32(constant)
+ // Into this: static_cast<uint64_t>(static_cast<uint32_t>(constant))
+ if (m_value->child(0)->hasInt32()) {
+ replaceWithNewValue(
+ m_proc.addIntConstant(
+ m_value,
+ static_cast<uint64_t>(static_cast<uint32_t>(m_value->child(0)->asInt32()))));
+ break;
+ }
+ break;
+
+ case Trunc:
+ // Turn this: Trunc(constant)
+ // Into this: static_cast<int32_t>(constant)
+ if (m_value->child(0)->hasInt64()) {
+ replaceWithNewValue(
+ m_proc.addIntConstant(m_value, static_cast<int32_t>(m_value->child(0)->asInt64())));
+ break;
+ }
+
+ // Turn this: Trunc(SExt32(value)) or Trunc(ZExt32(value))
+ // Into this: value
+ if (m_value->child(0)->opcode() == SExt32 || m_value->child(0)->opcode() == ZExt32) {
+ m_value->replaceWithIdentity(m_value->child(0)->child(0));
+ m_changed = true;
+ break;
+ }
+ break;
+
</ins><span class="cx"> case Load8Z:
</span><span class="cx"> case Load8S:
</span><span class="cx"> case Load16Z:
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airAirOpcodeopcodes"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/air/AirOpcode.opcodes (192664 => 192665)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/AirOpcode.opcodes        2015-11-19 23:32:09 UTC (rev 192664)
+++ trunk/Source/JavaScriptCore/b3/air/AirOpcode.opcodes        2015-11-19 23:35:50 UTC (rev 192665)
</span><span class="lines">@@ -225,6 +225,9 @@
</span><span class="cx"> Imm, Addr as store32
</span><span class="cx"> Imm, Index as store32
</span><span class="cx">
</span><ins>+SignExtend32ToPtr U:G, D:G
+ Tmp, Tmp
+
</ins><span class="cx"> MoveDouble U:F, D:F
</span><span class="cx"> Tmp, Tmp
</span><span class="cx"> Addr, Tmp as loadDouble
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3testb3cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/testb3.cpp (192664 => 192665)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/testb3.cpp        2015-11-19 23:32:09 UTC (rev 192664)
+++ trunk/Source/JavaScriptCore/b3/testb3.cpp        2015-11-19 23:35:50 UTC (rev 192665)
</span><span class="lines">@@ -4629,6 +4629,109 @@
</span><span class="cx"> CHECK(!invoke<int32_t>(*code, degree * gap + 1, 42, 11));
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+void testTruncFold(int64_t value)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ root->appendNew<ControlValue>(
+ proc, Return, Origin(),
+ root->appendNew<Value>(
+ proc, Trunc, Origin(),
+ root->appendNew<Const64Value>(proc, Origin(), value)));
+
+ CHECK(compileAndRun<int>(proc) == static_cast<int>(value));
+}
+
+void testZExt32(int32_t value)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ root->appendNew<ControlValue>(
+ proc, Return, Origin(),
+ root->appendNew<Value>(
+ proc, ZExt32, Origin(),
+ root->appendNew<Value>(
+ proc, Trunc, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))));
+
+ CHECK(compileAndRun<uint64_t>(proc, value) == static_cast<uint64_t>(static_cast<uint32_t>(value)));
+}
+
+void testZExt32Fold(int32_t value)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ root->appendNew<ControlValue>(
+ proc, Return, Origin(),
+ root->appendNew<Value>(
+ proc, ZExt32, Origin(),
+ root->appendNew<Const32Value>(proc, Origin(), value)));
+
+ CHECK(compileAndRun<uint64_t>(proc, value) == static_cast<uint64_t>(static_cast<uint32_t>(value)));
+}
+
+void testSExt32(int32_t value)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ root->appendNew<ControlValue>(
+ proc, Return, Origin(),
+ root->appendNew<Value>(
+ proc, SExt32, Origin(),
+ root->appendNew<Value>(
+ proc, Trunc, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0))));
+
+ CHECK(compileAndRun<int64_t>(proc, value) == static_cast<int64_t>(value));
+}
+
+void testSExt32Fold(int32_t value)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ root->appendNew<ControlValue>(
+ proc, Return, Origin(),
+ root->appendNew<Value>(
+ proc, SExt32, Origin(),
+ root->appendNew<Const32Value>(proc, Origin(), value)));
+
+ CHECK(compileAndRun<int64_t>(proc, value) == static_cast<int64_t>(value));
+}
+
+void testTruncZExt32(int32_t value)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ root->appendNew<ControlValue>(
+ proc, Return, Origin(),
+ root->appendNew<Value>(
+ proc, Trunc, Origin(),
+ root->appendNew<Value>(
+ proc, ZExt32, Origin(),
+ root->appendNew<Value>(
+ proc, Trunc, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)))));
+
+ CHECK(compileAndRun<int32_t>(proc, value) == value);
+}
+
+void testTruncSExt32(int32_t value)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ root->appendNew<ControlValue>(
+ proc, Return, Origin(),
+ root->appendNew<Value>(
+ proc, Trunc, Origin(),
+ root->appendNew<Value>(
+ proc, SExt32, Origin(),
+ root->appendNew<Value>(
+ proc, Trunc, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0)))));
+
+ CHECK(compileAndRun<int32_t>(proc, value) == value);
+}
+
</ins><span class="cx"> // Make sure the compiler does not try to optimize anything out.
</span><span class="cx"> NEVER_INLINE double zero()
</span><span class="cx"> {
</span><span class="lines">@@ -5378,6 +5481,50 @@
</span><span class="cx"> RUN(testSwitchChillDiv(100, 1));
</span><span class="cx"> RUN(testSwitchChillDiv(100, 100));
</span><span class="cx">
</span><ins>+ RUN(testTrunc(0));
+ RUN(testTrunc(1));
+ RUN(testTrunc(-1));
+ RUN(testTrunc(1000000000000ll));
+ RUN(testTrunc(-1000000000000ll));
+ RUN(testTruncFold(0));
+ RUN(testTruncFold(1));
+ RUN(testTruncFold(-1));
+ RUN(testTruncFold(1000000000000ll));
+ RUN(testTruncFold(-1000000000000ll));
+
+ RUN(testZExt32(0));
+ RUN(testZExt32(1));
+ RUN(testZExt32(-1));
+ RUN(testZExt32(1000000000ll));
+ RUN(testZExt32(-1000000000ll));
+ RUN(testZExt32Fold(0));
+ RUN(testZExt32Fold(1));
+ RUN(testZExt32Fold(-1));
+ RUN(testZExt32Fold(1000000000ll));
+ RUN(testZExt32Fold(-1000000000ll));
+
+ RUN(testSExt32(0));
+ RUN(testSExt32(1));
+ RUN(testSExt32(-1));
+ RUN(testSExt32(1000000000ll));
+ RUN(testSExt32(-1000000000ll));
+ RUN(testSExt32Fold(0));
+ RUN(testSExt32Fold(1));
+ RUN(testSExt32Fold(-1));
+ RUN(testSExt32Fold(1000000000ll));
+ RUN(testSExt32Fold(-1000000000ll));
+
+ RUN(testTruncZExt32(0));
+ RUN(testTruncZExt32(1));
+ RUN(testTruncZExt32(-1));
+ RUN(testTruncZExt32(1000000000ll));
+ RUN(testTruncZExt32(-1000000000ll));
+ RUN(testTruncSExt32(0));
+ RUN(testTruncSExt32(1));
+ RUN(testTruncSExt32(-1));
+ RUN(testTruncSExt32(1000000000ll));
+ RUN(testTruncSExt32(-1000000000ll));
+
</ins><span class="cx"> if (tasks.isEmpty())
</span><span class="cx"> usage();
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLB3Outputcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLB3Output.cpp (192664 => 192665)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLB3Output.cpp        2015-11-19 23:32:09 UTC (rev 192664)
+++ trunk/Source/JavaScriptCore/ftl/FTLB3Output.cpp        2015-11-19 23:35:50 UTC (rev 192665)
</span><span class="lines">@@ -110,6 +110,32 @@
</span><span class="cx"> pointer.heap().decorateInstruction(store, *m_heaps);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+LValue Output::baseIndex(LValue base, LValue index, Scale scale, ptrdiff_t offset)
+{
+ LValue accumulatedOffset;
+
+ switch (scale) {
+ case ScaleOne:
+ accumulatedOffset = index;
+ break;
+ case ScaleTwo:
+ accumulatedOffset = shl(index, intPtrOne);
+ break;
+ case ScaleFour:
+ accumulatedOffset = shl(index, intPtrTwo);
+ break;
+ case ScaleEight:
+ case ScalePtr:
+ accumulatedOffset = shl(index, intPtrThree);
+ break;
+ }
+
+ if (offset)
+ accumulatedOffset = add(accumulatedOffset, constIntPtr(offset));
+
+ return add(base, accumulatedOffset);
+}
+
</ins><span class="cx"> void Output::branch(LValue condition, LBasicBlock taken, Weight takenWeight, LBasicBlock notTaken, Weight notTakenWeight)
</span><span class="cx"> {
</span><span class="cx"> m_block->appendNew<B3::ControlValue>(
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLB3Outputh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLB3Output.h (192664 => 192665)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLB3Output.h        2015-11-19 23:32:09 UTC (rev 192664)
+++ trunk/Source/JavaScriptCore/ftl/FTLB3Output.h        2015-11-19 23:35:50 UTC (rev 192665)
</span><span class="lines">@@ -142,9 +142,9 @@
</span><span class="cx"> LValue bitAnd(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::BitAnd, origin(), left, right); }
</span><span class="cx"> LValue bitOr(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::BitOr, origin(), left, right); }
</span><span class="cx"> LValue bitXor(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::BitXor, origin(), left, right); }
</span><del>- LValue shl(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Shl, origin(), left, right); }
- LValue aShr(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::SShr, origin(), left, right); }
- LValue lShr(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::ZShr, origin(), left, right); }
</del><ins>+ LValue shl(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Shl, origin(), left, castToInt32(right)); }
+ LValue aShr(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::SShr, origin(), left, castToInt32(right)); }
+ LValue lShr(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::ZShr, origin(), left, castToInt32(right)); }
</ins><span class="cx"> LValue bitNot(LValue value) { CRASH(); }
</span><span class="cx">
</span><span class="cx"> LValue insertElement(LValue vector, LValue element, LValue index) { CRASH(); }
</span><span class="lines">@@ -245,7 +245,7 @@
</span><span class="cx"> return address(field, base, offset + field.offset());
</span><span class="cx"> }
</span><span class="cx">
</span><del>- LValue baseIndex(LValue base, LValue index, Scale, ptrdiff_t offset = 0) { CRASH(); }
</del><ins>+ LValue baseIndex(LValue base, LValue index, Scale, ptrdiff_t offset = 0);
</ins><span class="cx">
</span><span class="cx"> TypedPointer baseIndex(const AbstractHeap& heap, LValue base, LValue index, Scale scale, ptrdiff_t offset = 0)
</span><span class="cx"> {
</span></span></pre>
</div>
</div>
</body>
</html>