<!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>[194341] 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/194341">194341</a></dd>
<dt>Author</dt> <dd>fpizlo@apple.com</dd>
<dt>Date</dt> <dd>2015-12-21 12:54:51 -0800 (Mon, 21 Dec 2015)</dd>
</dl>
<h3>Log Message</h3>
<pre>FTL B3 should do doubleToInt32
https://bugs.webkit.org/show_bug.cgi?id=152484
Reviewed by Saam Barati.
We used to have a DToI32 opcode in B3 that we never implemented. This removes that opcode,
since double-to-int conversion has dramatically different semantics on different
architectures. We let FTL get the conversion instruction it wants by using a patchpoint.
* b3/B3Opcode.cpp:
(WTF::printInternal):
* b3/B3Opcode.h:
* b3/B3Validate.cpp:
* b3/B3Value.cpp:
(JSC::B3::Value::effects):
(JSC::B3::Value::key):
(JSC::B3::Value::typeFor):
* b3/B3ValueKey.cpp:
(JSC::B3::ValueKey::materialize):
* ftl/FTLB3Output.cpp:
(JSC::FTL::Output::Output):
(JSC::FTL::Output::appendTo):
(JSC::FTL::Output::lockedStackSlot):
(JSC::FTL::Output::load):
(JSC::FTL::Output::doublePowi):
(JSC::FTL::Output::hasSensibleDoubleToInt):
(JSC::FTL::Output::doubleToInt):
(JSC::FTL::Output::doubleToUInt):
(JSC::FTL::Output::load8SignExt32):
(JSC::FTL::Output::load8ZeroExt32):
(JSC::FTL::Output::load16SignExt32):
(JSC::FTL::Output::load16ZeroExt32):
(JSC::FTL::Output::store):
(JSC::FTL::Output::store32As8):
(JSC::FTL::Output::store32As16):
(JSC::FTL::Output::branch):
* ftl/FTLB3Output.h:
(JSC::FTL::Output::doubleLog):
(JSC::FTL::Output::signExt32To64):
(JSC::FTL::Output::zeroExt):
(JSC::FTL::Output::zeroExtPtr):
(JSC::FTL::Output::intToDouble):
(JSC::FTL::Output::unsignedToDouble):
(JSC::FTL::Output::castToInt32):
(JSC::FTL::Output::hasSensibleDoubleToInt): Deleted.
(JSC::FTL::Output::sensibleDoubleToInt): Deleted.
(JSC::FTL::Output::fpToInt32): Deleted.
(JSC::FTL::Output::fpToUInt32): Deleted.
* ftl/FTLLowerDFGToLLVM.cpp:
(JSC::FTL::DFG::LowerDFGToLLVM::compileArithPow):
(JSC::FTL::DFG::LowerDFGToLLVM::compilePutByVal):
(JSC::FTL::DFG::LowerDFGToLLVM::compileSwitch):
(JSC::FTL::DFG::LowerDFGToLLVM::doubleToInt32):
(JSC::FTL::DFG::LowerDFGToLLVM::sensibleDoubleToInt32):
(JSC::FTL::DFG::LowerDFGToLLVM::convertDoubleToInt32):
* ftl/FTLOutput.h:
(JSC::FTL::Output::hasSensibleDoubleToInt):
(JSC::FTL::Output::doubleToInt):
(JSC::FTL::Output::doubleToUInt):
(JSC::FTL::Output::signExt32To64):
(JSC::FTL::Output::zeroExt):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3Opcodecpp">trunk/Source/JavaScriptCore/b3/B3Opcode.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3Opcodeh">trunk/Source/JavaScriptCore/b3/B3Opcode.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3Validatecpp">trunk/Source/JavaScriptCore/b3/B3Validate.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3Valuecpp">trunk/Source/JavaScriptCore/b3/B3Value.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3ValueKeycpp">trunk/Source/JavaScriptCore/b3/B3ValueKey.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>
<li><a href="#trunkSourceJavaScriptCoreftlFTLLowerDFGToLLVMcpp">trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLOutputh">trunk/Source/JavaScriptCore/ftl/FTLOutput.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (194340 => 194341)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2015-12-21 20:40:04 UTC (rev 194340)
+++ trunk/Source/JavaScriptCore/ChangeLog 2015-12-21 20:54:51 UTC (rev 194341)
</span><span class="lines">@@ -1,3 +1,67 @@
</span><ins>+2015-12-21 Filip Pizlo <fpizlo@apple.com>
+
+ FTL B3 should do doubleToInt32
+ https://bugs.webkit.org/show_bug.cgi?id=152484
+
+ Reviewed by Saam Barati.
+
+ We used to have a DToI32 opcode in B3 that we never implemented. This removes that opcode,
+ since double-to-int conversion has dramatically different semantics on different
+ architectures. We let FTL get the conversion instruction it wants by using a patchpoint.
+
+ * b3/B3Opcode.cpp:
+ (WTF::printInternal):
+ * b3/B3Opcode.h:
+ * b3/B3Validate.cpp:
+ * b3/B3Value.cpp:
+ (JSC::B3::Value::effects):
+ (JSC::B3::Value::key):
+ (JSC::B3::Value::typeFor):
+ * b3/B3ValueKey.cpp:
+ (JSC::B3::ValueKey::materialize):
+ * ftl/FTLB3Output.cpp:
+ (JSC::FTL::Output::Output):
+ (JSC::FTL::Output::appendTo):
+ (JSC::FTL::Output::lockedStackSlot):
+ (JSC::FTL::Output::load):
+ (JSC::FTL::Output::doublePowi):
+ (JSC::FTL::Output::hasSensibleDoubleToInt):
+ (JSC::FTL::Output::doubleToInt):
+ (JSC::FTL::Output::doubleToUInt):
+ (JSC::FTL::Output::load8SignExt32):
+ (JSC::FTL::Output::load8ZeroExt32):
+ (JSC::FTL::Output::load16SignExt32):
+ (JSC::FTL::Output::load16ZeroExt32):
+ (JSC::FTL::Output::store):
+ (JSC::FTL::Output::store32As8):
+ (JSC::FTL::Output::store32As16):
+ (JSC::FTL::Output::branch):
+ * ftl/FTLB3Output.h:
+ (JSC::FTL::Output::doubleLog):
+ (JSC::FTL::Output::signExt32To64):
+ (JSC::FTL::Output::zeroExt):
+ (JSC::FTL::Output::zeroExtPtr):
+ (JSC::FTL::Output::intToDouble):
+ (JSC::FTL::Output::unsignedToDouble):
+ (JSC::FTL::Output::castToInt32):
+ (JSC::FTL::Output::hasSensibleDoubleToInt): Deleted.
+ (JSC::FTL::Output::sensibleDoubleToInt): Deleted.
+ (JSC::FTL::Output::fpToInt32): Deleted.
+ (JSC::FTL::Output::fpToUInt32): Deleted.
+ * ftl/FTLLowerDFGToLLVM.cpp:
+ (JSC::FTL::DFG::LowerDFGToLLVM::compileArithPow):
+ (JSC::FTL::DFG::LowerDFGToLLVM::compilePutByVal):
+ (JSC::FTL::DFG::LowerDFGToLLVM::compileSwitch):
+ (JSC::FTL::DFG::LowerDFGToLLVM::doubleToInt32):
+ (JSC::FTL::DFG::LowerDFGToLLVM::sensibleDoubleToInt32):
+ (JSC::FTL::DFG::LowerDFGToLLVM::convertDoubleToInt32):
+ * ftl/FTLOutput.h:
+ (JSC::FTL::Output::hasSensibleDoubleToInt):
+ (JSC::FTL::Output::doubleToInt):
+ (JSC::FTL::Output::doubleToUInt):
+ (JSC::FTL::Output::signExt32To64):
+ (JSC::FTL::Output::zeroExt):
+
</ins><span class="cx"> 2015-12-21 Skachkov Oleksandr <gskachkov@gmail.com>
</span><span class="cx">
</span><span class="cx"> Unexpected exception assigning to this._property inside arrow function
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3Opcodecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3Opcode.cpp (194340 => 194341)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3Opcode.cpp 2015-12-21 20:40:04 UTC (rev 194340)
+++ trunk/Source/JavaScriptCore/b3/B3Opcode.cpp 2015-12-21 20:54:51 UTC (rev 194341)
</span><span class="lines">@@ -176,9 +176,6 @@
</span><span class="cx"> case IToD:
</span><span class="cx"> out.print("IToD");
</span><span class="cx"> return;
</span><del>- case DToI32:
- out.print("DToI32");
- return;
</del><span class="cx"> case FloatToDouble:
</span><span class="cx"> out.print("FloatToDouble");
</span><span class="cx"> return;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3Opcodeh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3Opcode.h (194340 => 194341)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3Opcode.h 2015-12-21 20:40:04 UTC (rev 194340)
+++ trunk/Source/JavaScriptCore/b3/B3Opcode.h 2015-12-21 20:54:51 UTC (rev 194341)
</span><span class="lines">@@ -100,10 +100,10 @@
</span><span class="cx"> ZExt32,
</span><span class="cx"> // Takes Int64 and returns Int32:
</span><span class="cx"> Trunc,
</span><del>- // Takes ints and returns Double:
</del><ins>+ // Takes ints and returns Double. Note that we don't currently provide the opposite operation,
+ // because double-to-int conversions have weirdly different semantics on different platforms. Use
+ // a patchpoint if you need to do that.
</ins><span class="cx"> IToD,
</span><del>- // Takes Double and returns Int32:
- DToI32,
</del><span class="cx"> // Convert between double and float.
</span><span class="cx"> FloatToDouble,
</span><span class="cx"> DoubleToFloat,
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3Validatecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3Validate.cpp (194340 => 194341)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3Validate.cpp 2015-12-21 20:40:04 UTC (rev 194340)
+++ trunk/Source/JavaScriptCore/b3/B3Validate.cpp 2015-12-21 20:54:51 UTC (rev 194341)
</span><span class="lines">@@ -221,11 +221,6 @@
</span><span class="cx"> VALIDATE(isInt(value->child(0)->type()), ("At ", *value));
</span><span class="cx"> VALIDATE(value->type() == Double, ("At ", *value));
</span><span class="cx"> break;
</span><del>- case DToI32:
- VALIDATE(value->numChildren() == 1, ("At ", *value));
- VALIDATE(value->child(0)->type() == Double, ("At ", *value));
- VALIDATE(value->type() == Int32, ("At ", *value));
- break;
</del><span class="cx"> case FloatToDouble:
</span><span class="cx"> VALIDATE(value->numChildren() == 1, ("At ", *value));
</span><span class="cx"> VALIDATE(value->child(0)->type() == Float, ("At ", *value));
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3Valuecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3Value.cpp (194340 => 194341)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3Value.cpp 2015-12-21 20:40:04 UTC (rev 194340)
+++ trunk/Source/JavaScriptCore/b3/B3Value.cpp 2015-12-21 20:54:51 UTC (rev 194341)
</span><span class="lines">@@ -383,7 +383,6 @@
</span><span class="cx"> case ZExt32:
</span><span class="cx"> case Trunc:
</span><span class="cx"> case IToD:
</span><del>- case DToI32:
</del><span class="cx"> case FloatToDouble:
</span><span class="cx"> case DoubleToFloat:
</span><span class="cx"> case Equal:
</span><span class="lines">@@ -464,7 +463,6 @@
</span><span class="cx"> case Clz:
</span><span class="cx"> case Trunc:
</span><span class="cx"> case IToD:
</span><del>- case DToI32:
</del><span class="cx"> case FloatToDouble:
</span><span class="cx"> case DoubleToFloat:
</span><span class="cx"> case Check:
</span><span class="lines">@@ -575,7 +573,6 @@
</span><span class="cx"> case SExt8:
</span><span class="cx"> case SExt16:
</span><span class="cx"> case Trunc:
</span><del>- case DToI32:
</del><span class="cx"> case Equal:
</span><span class="cx"> case NotEqual:
</span><span class="cx"> case LessThan:
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3ValueKeycpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3ValueKey.cpp (194340 => 194341)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3ValueKey.cpp 2015-12-21 20:40:04 UTC (rev 194340)
+++ trunk/Source/JavaScriptCore/b3/B3ValueKey.cpp 2015-12-21 20:54:51 UTC (rev 194341)
</span><span class="lines">@@ -54,7 +54,6 @@
</span><span class="cx"> case Clz:
</span><span class="cx"> case Trunc:
</span><span class="cx"> case IToD:
</span><del>- case DToI32:
</del><span class="cx"> case FloatToDouble:
</span><span class="cx"> case DoubleToFloat:
</span><span class="cx"> case Check:
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLB3Outputcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLB3Output.cpp (194340 => 194341)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLB3Output.cpp 2015-12-21 20:40:04 UTC (rev 194340)
+++ trunk/Source/JavaScriptCore/ftl/FTLB3Output.cpp 2015-12-21 20:54:51 UTC (rev 194341)
</span><span class="lines">@@ -30,9 +30,12 @@
</span><span class="cx"> #if FTL_USES_B3
</span><span class="cx">
</span><span class="cx"> #include "B3MathExtras.h"
</span><ins>+#include "B3StackmapGenerationParams.h"
</ins><span class="cx">
</span><span class="cx"> namespace JSC { namespace FTL {
</span><span class="cx">
</span><ins>+using namespace B3;
+
</ins><span class="cx"> Output::Output(State& state)
</span><span class="cx"> : CommonValues(state.context)
</span><span class="cx"> , m_proc(*state.proc)
</span><span class="lines">@@ -59,68 +62,100 @@
</span><span class="cx"> m_block = block;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-B3::StackSlotValue* Output::lockedStackSlot(size_t bytes)
</del><ins>+StackSlotValue* Output::lockedStackSlot(size_t bytes)
</ins><span class="cx"> {
</span><del>- return m_block->appendNew<B3::StackSlotValue>(m_proc, origin(), bytes, B3::StackSlotKind::Locked);
</del><ins>+ return m_block->appendNew<StackSlotValue>(m_proc, origin(), bytes, StackSlotKind::Locked);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> LValue Output::load(TypedPointer pointer, LType type)
</span><span class="cx"> {
</span><del>- LValue load = m_block->appendNew<B3::MemoryValue>(m_proc, B3::Load, type, origin(), pointer.value());
</del><ins>+ LValue load = m_block->appendNew<MemoryValue>(m_proc, Load, type, origin(), pointer.value());
</ins><span class="cx"> pointer.heap().decorateInstruction(load, *m_heaps);
</span><span class="cx"> return load;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> LValue Output::doublePowi(LValue x, LValue y)
</span><span class="cx"> {
</span><ins>+ // FIXME: powDoubleInt32() should be inlined here since Output knows about block layout and
+ // should be involved in any operation that creates blocks.
+ // https://bugs.webkit.org/show_bug.cgi?id=152223
</ins><span class="cx"> auto result = powDoubleInt32(m_proc, m_block, origin(), x, y);
</span><span class="cx"> m_block = result.first;
</span><span class="cx"> return result.second;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+bool Output::hasSensibleDoubleToInt()
+{
+ return optimizeForX86();
+}
+
+LValue Output::doubleToInt(LValue value)
+{
+ PatchpointValue* result = patchpoint(Int32);
+ result->append(value, ValueRep::SomeRegister);
+ result->setGenerator(
+ [] (CCallHelpers& jit, const StackmapGenerationParams& params) {
+ jit.truncateDoubleToInt32(params[1].fpr(), params[0].gpr());
+ });
+ result->effects = Effects::none();
+ return result;
+}
+
+LValue Output::doubleToUInt(LValue value)
+{
+ PatchpointValue* result = patchpoint(Int32);
+ result->append(value, ValueRep::SomeRegister);
+ result->setGenerator(
+ [] (CCallHelpers& jit, const StackmapGenerationParams& params) {
+ jit.truncateDoubleToUint32(params[1].fpr(), params[0].gpr());
+ });
+ result->effects = Effects::none();
+ return result;
+}
+
</ins><span class="cx"> LValue Output::load8SignExt32(TypedPointer pointer)
</span><span class="cx"> {
</span><del>- LValue load = m_block->appendNew<B3::MemoryValue>(m_proc, B3::Load8S, B3::Int32, origin(), pointer.value());
</del><ins>+ LValue load = m_block->appendNew<MemoryValue>(m_proc, Load8S, Int32, origin(), pointer.value());
</ins><span class="cx"> pointer.heap().decorateInstruction(load, *m_heaps);
</span><span class="cx"> return load;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> LValue Output::load8ZeroExt32(TypedPointer pointer)
</span><span class="cx"> {
</span><del>- LValue load = m_block->appendNew<B3::MemoryValue>(m_proc, B3::Load8Z, B3::Int32, origin(), pointer.value());
</del><ins>+ LValue load = m_block->appendNew<MemoryValue>(m_proc, Load8Z, Int32, origin(), pointer.value());
</ins><span class="cx"> pointer.heap().decorateInstruction(load, *m_heaps);
</span><span class="cx"> return load;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> LValue Output::load16SignExt32(TypedPointer pointer)
</span><span class="cx"> {
</span><del>- LValue load = m_block->appendNew<B3::MemoryValue>(m_proc, B3::Load16S, B3::Int32, origin(), pointer.value());
</del><ins>+ LValue load = m_block->appendNew<MemoryValue>(m_proc, Load16S, Int32, origin(), pointer.value());
</ins><span class="cx"> pointer.heap().decorateInstruction(load, *m_heaps);
</span><span class="cx"> return load;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> LValue Output::load16ZeroExt32(TypedPointer pointer)
</span><span class="cx"> {
</span><del>- LValue load = m_block->appendNew<B3::MemoryValue>(m_proc, B3::Load16Z, B3::Int32, origin(), pointer.value());
</del><ins>+ LValue load = m_block->appendNew<MemoryValue>(m_proc, Load16Z, Int32, origin(), pointer.value());
</ins><span class="cx"> pointer.heap().decorateInstruction(load, *m_heaps);
</span><span class="cx"> return load;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void Output::store(LValue value, TypedPointer pointer)
</span><span class="cx"> {
</span><del>- LValue store = m_block->appendNew<B3::MemoryValue>(m_proc, B3::Store, origin(), value, pointer.value());
</del><ins>+ LValue store = m_block->appendNew<MemoryValue>(m_proc, Store, origin(), value, pointer.value());
</ins><span class="cx"> pointer.heap().decorateInstruction(store, *m_heaps);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void Output::store32As8(LValue value, TypedPointer pointer)
</span><span class="cx"> {
</span><del>- LValue store = m_block->appendNew<B3::MemoryValue>(m_proc, B3::Store8, origin(), value, pointer.value());
</del><ins>+ LValue store = m_block->appendNew<MemoryValue>(m_proc, Store8, origin(), value, pointer.value());
</ins><span class="cx"> pointer.heap().decorateInstruction(store, *m_heaps);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void Output::store32As16(LValue value, TypedPointer pointer)
</span><span class="cx"> {
</span><del>- LValue store = m_block->appendNew<B3::MemoryValue>(m_proc, B3::Store16, origin(), value, pointer.value());
</del><ins>+ LValue store = m_block->appendNew<MemoryValue>(m_proc, Store16, origin(), value, pointer.value());
</ins><span class="cx"> pointer.heap().decorateInstruction(store, *m_heaps);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -152,10 +187,10 @@
</span><span class="cx">
</span><span class="cx"> void Output::branch(LValue condition, LBasicBlock taken, Weight takenWeight, LBasicBlock notTaken, Weight notTakenWeight)
</span><span class="cx"> {
</span><del>- m_block->appendNew<B3::ControlValue>(
</del><ins>+ m_block->appendNew<ControlValue>(
</ins><span class="cx"> m_proc, B3::Branch, origin(), condition,
</span><del>- B3::FrequentedBlock(taken, takenWeight.frequencyClass()),
- B3::FrequentedBlock(notTaken, notTakenWeight.frequencyClass()));
</del><ins>+ FrequentedBlock(taken, takenWeight.frequencyClass()),
+ FrequentedBlock(notTaken, notTakenWeight.frequencyClass()));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> } } // namespace JSC::FTL
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLB3Outputh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLB3Output.h (194340 => 194341)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLB3Output.h 2015-12-21 20:40:04 UTC (rev 194340)
+++ trunk/Source/JavaScriptCore/ftl/FTLB3Output.h 2015-12-21 20:54:51 UTC (rev 194341)
</span><span class="lines">@@ -175,8 +175,9 @@
</span><span class="cx">
</span><span class="cx"> LValue doubleLog(LValue value) { return callWithoutSideEffects(B3::Double, log, value); }
</span><span class="cx">
</span><del>- static bool hasSensibleDoubleToInt() { CRASH(); }
- LValue sensibleDoubleToInt(LValue) { CRASH(); }
</del><ins>+ static bool hasSensibleDoubleToInt();
+ LValue doubleToInt(LValue);
+ LValue doubleToUInt(LValue);
</ins><span class="cx">
</span><span class="cx"> LValue signExt32To64(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::SExt32, origin(), value); }
</span><span class="cx"> LValue zeroExt(LValue value, LType type)
</span><span class="lines">@@ -186,8 +187,6 @@
</span><span class="cx"> return m_block->appendNew<B3::Value>(m_proc, B3::ZExt32, origin(), value);
</span><span class="cx"> }
</span><span class="cx"> LValue zeroExtPtr(LValue value) { return zeroExt(value, B3::Int64); }
</span><del>- LValue fpToInt32(LValue value) { CRASH(); }
- LValue fpToUInt32(LValue value) { CRASH(); }
</del><span class="cx"> LValue intToDouble(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::IToD, origin(), value); }
</span><span class="cx"> LValue unsignedToDouble(LValue value) { CRASH(); }
</span><span class="cx"> LValue castToInt32(LValue value)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLLowerDFGToLLVMcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp (194340 => 194341)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp 2015-12-21 20:40:04 UTC (rev 194340)
+++ trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp 2015-12-21 20:54:51 UTC (rev 194341)
</span><span class="lines">@@ -2084,7 +2084,7 @@
</span><span class="cx"> LBasicBlock nanExceptionResultIsNaN = FTL_NEW_BLOCK(m_out, ("ArithPow NaN Exception, result is NaN."));
</span><span class="cx"> LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ArithPow continuation"));
</span><span class="cx">
</span><del>- LValue integerExponent = m_out.fpToInt32(exponent);
</del><ins>+ LValue integerExponent = m_out.doubleToInt(exponent);
</ins><span class="cx"> LValue integerExponentConvertedToDouble = m_out.intToDouble(integerExponent);
</span><span class="cx"> LValue exponentIsInteger = m_out.doubleEqual(exponent, integerExponentConvertedToDouble);
</span><span class="cx"> m_out.branch(exponentIsInteger, unsure(integerExponentIsSmallBlock), unsure(doubleExponentPowBlockEntry));
</span><span class="lines">@@ -3282,7 +3282,7 @@
</span><span class="cx"> unsure(continuation), unsure(withinRange));
</span><span class="cx">
</span><span class="cx"> m_out.appendTo(withinRange, continuation);
</span><del>- intValues.append(m_out.anchor(m_out.fpToInt32(doubleValue)));
</del><ins>+ intValues.append(m_out.anchor(m_out.doubleToInt(doubleValue)));
</ins><span class="cx"> m_out.jump(continuation);
</span><span class="cx">
</span><span class="cx"> m_out.appendTo(continuation, lastNext);
</span><span class="lines">@@ -5513,7 +5513,7 @@
</span><span class="cx">
</span><span class="cx"> m_out.appendTo(isDouble, innerLastNext);
</span><span class="cx"> LValue doubleValue = unboxDouble(boxedValue);
</span><del>- LValue intInDouble = m_out.fpToInt32(doubleValue);
</del><ins>+ LValue intInDouble = m_out.doubleToInt(doubleValue);
</ins><span class="cx"> intValues.append(m_out.anchor(intInDouble));
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.doubleEqual(m_out.intToDouble(intInDouble), doubleValue),
</span><span class="lines">@@ -8274,9 +8274,9 @@
</span><span class="cx"> m_out.appendTo(withinRange, slowPath);
</span><span class="cx"> LValue fastResult;
</span><span class="cx"> if (isSigned)
</span><del>- fastResult = m_out.fpToInt32(doubleValue);
</del><ins>+ fastResult = m_out.doubleToInt(doubleValue);
</ins><span class="cx"> else
</span><del>- fastResult = m_out.fpToUInt32(doubleValue);
</del><ins>+ fastResult = m_out.doubleToUInt(doubleValue);
</ins><span class="cx"> results.append(m_out.anchor(fastResult));
</span><span class="cx"> m_out.jump(continuation);
</span><span class="cx">
</span><span class="lines">@@ -8302,7 +8302,7 @@
</span><span class="cx"> LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("sensible doubleToInt32 slow path"));
</span><span class="cx"> LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("sensible doubleToInt32 continuation"));
</span><span class="cx">
</span><del>- LValue fastResultValue = m_out.sensibleDoubleToInt(doubleValue);
</del><ins>+ LValue fastResultValue = m_out.doubleToInt(doubleValue);
</ins><span class="cx"> ValueFromBlock fastResult = m_out.anchor(fastResultValue);
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.equal(fastResultValue, m_out.constInt32(0x80000000)),
</span><span class="lines">@@ -8958,7 +8958,7 @@
</span><span class="cx">
</span><span class="cx"> LValue convertDoubleToInt32(LValue value, bool shouldCheckNegativeZero)
</span><span class="cx"> {
</span><del>- LValue integerValue = m_out.fpToInt32(value);
</del><ins>+ LValue integerValue = m_out.doubleToInt(value);
</ins><span class="cx"> LValue integerValueConvertedToDouble = m_out.intToDouble(integerValue);
</span><span class="cx"> LValue valueNotConvertibleToInteger = m_out.doubleNotEqualOrUnordered(value, integerValueConvertedToDouble);
</span><span class="cx"> speculate(Overflow, FormattedValue(DataFormatDouble, value), m_node, valueNotConvertibleToInteger);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLOutputh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLOutput.h (194340 => 194341)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLOutput.h 2015-12-21 20:40:04 UTC (rev 194340)
+++ trunk/Source/JavaScriptCore/ftl/FTLOutput.h 2015-12-21 20:54:51 UTC (rev 194341)
</span><span class="lines">@@ -215,6 +215,8 @@
</span><span class="cx">
</span><span class="cx"> static bool hasSensibleDoubleToInt() { return isX86(); }
</span><span class="cx"> LValue sensibleDoubleToInt(LValue);
</span><ins>+ LValue doubleToInt(LValue value) { return fpToInt32(value); }
+ LValue doubleToUInt(LValue value) { return fpToUInt32(value); }
</ins><span class="cx">
</span><span class="cx"> LValue signExt32To64(LValue value) { return signExt(value, int64); }
</span><span class="cx"> LValue zeroExt(LValue value, LType type) { return buildZExt(m_builder, value, type); }
</span></span></pre>
</div>
</div>
</body>
</html>