<!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>[194062] 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/194062">194062</a></dd>
<dt>Author</dt> <dd>commit-queue@webkit.org</dd>
<dt>Date</dt> <dd>2015-12-14 14:44:22 -0800 (Mon, 14 Dec 2015)</dd>
</dl>
<h3>Log Message</h3>
<pre>[JSC] Add ceil() support for x86 and expose it to B3
https://bugs.webkit.org/show_bug.cgi?id=152231
Patch by Benjamin Poulain <bpoulain@apple.com> on 2015-12-14
Reviewed by Geoffrey Garen.
Most x86 CPUs we care about support ceil() natively
with the round instruction.
This patch expose that behind a runtime flag, use it
in the Math.ceil() thunk and expose it to B3.
* assembler/MacroAssemblerARM64.h:
(JSC::MacroAssemblerARM64::supportsFloatingPointCeil):
* assembler/MacroAssemblerARMv7.h:
(JSC::MacroAssemblerARMv7::supportsFloatingPointCeil):
* assembler/MacroAssemblerMIPS.h:
(JSC::MacroAssemblerMIPS::supportsFloatingPointCeil):
* assembler/MacroAssemblerSH4.h:
(JSC::MacroAssemblerSH4::supportsFloatingPointCeil):
* assembler/MacroAssemblerX86Common.cpp:
* assembler/MacroAssemblerX86Common.h:
(JSC::MacroAssemblerX86Common::ceilDouble):
(JSC::MacroAssemblerX86Common::ceilFloat):
(JSC::MacroAssemblerX86Common::supportsFloatingPointCeil):
(JSC::MacroAssemblerX86Common::supportsLZCNT):
* assembler/X86Assembler.h:
(JSC::X86Assembler::roundss_rr):
(JSC::X86Assembler::roundss_mr):
(JSC::X86Assembler::roundsd_rr):
(JSC::X86Assembler::roundsd_mr):
(JSC::X86Assembler::mfence):
(JSC::X86Assembler::X86InstructionFormatter::threeByteOp):
* b3/B3ConstDoubleValue.cpp:
(JSC::B3::ConstDoubleValue::ceilConstant):
* b3/B3ConstDoubleValue.h:
* b3/B3ConstFloatValue.cpp:
(JSC::B3::ConstFloatValue::ceilConstant):
* b3/B3ConstFloatValue.h:
* b3/B3LowerMacrosAfterOptimizations.cpp:
* b3/B3LowerToAir.cpp:
(JSC::B3::Air::LowerToAir::lower):
* b3/B3Opcode.cpp:
(WTF::printInternal):
* b3/B3Opcode.h:
* b3/B3ReduceDoubleToFloat.cpp:
* b3/B3ReduceStrength.cpp:
* b3/B3Validate.cpp:
* b3/B3Value.cpp:
(JSC::B3::Value::ceilConstant):
(JSC::B3::Value::effects):
(JSC::B3::Value::key):
(JSC::B3::Value::typeFor):
* b3/B3Value.h:
* b3/air/AirOpcode.opcodes:
* b3/testb3.cpp:
(JSC::B3::testCeilArg):
(JSC::B3::testCeilImm):
(JSC::B3::testCeilMem):
(JSC::B3::testCeilCeilArg):
(JSC::B3::testCeilIToD64):
(JSC::B3::testCeilIToD32):
(JSC::B3::testCeilArgWithUselessDoubleConversion):
(JSC::B3::testCeilArgWithEffectfulDoubleConversion):
(JSC::B3::populateWithInterestingValues):
(JSC::B3::run):
* ftl/FTLB3Output.h:
(JSC::FTL::Output::ceil64):
* jit/ThunkGenerators.cpp:
(JSC::ceilThunkGenerator):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerARM64h">trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerARMv7h">trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerMIPSh">trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerSH4h">trunk/Source/JavaScriptCore/assembler/MacroAssemblerSH4.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerX86Commoncpp">trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerMacroAssemblerX86Commonh">trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreassemblerX86Assemblerh">trunk/Source/JavaScriptCore/assembler/X86Assembler.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3ConstDoubleValuecpp">trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3ConstDoubleValueh">trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3ConstFloatValuecpp">trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3ConstFloatValueh">trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3LowerMacrosAfterOptimizationscpp">trunk/Source/JavaScriptCore/b3/B3LowerMacrosAfterOptimizations.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3LowerToAircpp">trunk/Source/JavaScriptCore/b3/B3LowerToAir.cpp</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="#trunkSourceJavaScriptCoreb3B3ReduceDoubleToFloatcpp">trunk/Source/JavaScriptCore/b3/B3ReduceDoubleToFloat.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreb3B3ReduceStrengthcpp">trunk/Source/JavaScriptCore/b3/B3ReduceStrength.cpp</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="#trunkSourceJavaScriptCoreb3B3Valueh">trunk/Source/JavaScriptCore/b3/B3Value.h</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="#trunkSourceJavaScriptCoreftlFTLB3Outputh">trunk/Source/JavaScriptCore/ftl/FTLB3Output.h</a></li>
<li><a href="#trunkSourceJavaScriptCorejitThunkGeneratorscpp">trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/ChangeLog 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -1,3 +1,75 @@
</span><ins>+2015-12-14 Benjamin Poulain <bpoulain@apple.com>
+
+ [JSC] Add ceil() support for x86 and expose it to B3
+ https://bugs.webkit.org/show_bug.cgi?id=152231
+
+ Reviewed by Geoffrey Garen.
+
+ Most x86 CPUs we care about support ceil() natively
+ with the round instruction.
+
+ This patch expose that behind a runtime flag, use it
+ in the Math.ceil() thunk and expose it to B3.
+
+ * assembler/MacroAssemblerARM64.h:
+ (JSC::MacroAssemblerARM64::supportsFloatingPointCeil):
+ * assembler/MacroAssemblerARMv7.h:
+ (JSC::MacroAssemblerARMv7::supportsFloatingPointCeil):
+ * assembler/MacroAssemblerMIPS.h:
+ (JSC::MacroAssemblerMIPS::supportsFloatingPointCeil):
+ * assembler/MacroAssemblerSH4.h:
+ (JSC::MacroAssemblerSH4::supportsFloatingPointCeil):
+ * assembler/MacroAssemblerX86Common.cpp:
+ * assembler/MacroAssemblerX86Common.h:
+ (JSC::MacroAssemblerX86Common::ceilDouble):
+ (JSC::MacroAssemblerX86Common::ceilFloat):
+ (JSC::MacroAssemblerX86Common::supportsFloatingPointCeil):
+ (JSC::MacroAssemblerX86Common::supportsLZCNT):
+ * assembler/X86Assembler.h:
+ (JSC::X86Assembler::roundss_rr):
+ (JSC::X86Assembler::roundss_mr):
+ (JSC::X86Assembler::roundsd_rr):
+ (JSC::X86Assembler::roundsd_mr):
+ (JSC::X86Assembler::mfence):
+ (JSC::X86Assembler::X86InstructionFormatter::threeByteOp):
+ * b3/B3ConstDoubleValue.cpp:
+ (JSC::B3::ConstDoubleValue::ceilConstant):
+ * b3/B3ConstDoubleValue.h:
+ * b3/B3ConstFloatValue.cpp:
+ (JSC::B3::ConstFloatValue::ceilConstant):
+ * b3/B3ConstFloatValue.h:
+ * b3/B3LowerMacrosAfterOptimizations.cpp:
+ * b3/B3LowerToAir.cpp:
+ (JSC::B3::Air::LowerToAir::lower):
+ * b3/B3Opcode.cpp:
+ (WTF::printInternal):
+ * b3/B3Opcode.h:
+ * b3/B3ReduceDoubleToFloat.cpp:
+ * b3/B3ReduceStrength.cpp:
+ * b3/B3Validate.cpp:
+ * b3/B3Value.cpp:
+ (JSC::B3::Value::ceilConstant):
+ (JSC::B3::Value::effects):
+ (JSC::B3::Value::key):
+ (JSC::B3::Value::typeFor):
+ * b3/B3Value.h:
+ * b3/air/AirOpcode.opcodes:
+ * b3/testb3.cpp:
+ (JSC::B3::testCeilArg):
+ (JSC::B3::testCeilImm):
+ (JSC::B3::testCeilMem):
+ (JSC::B3::testCeilCeilArg):
+ (JSC::B3::testCeilIToD64):
+ (JSC::B3::testCeilIToD32):
+ (JSC::B3::testCeilArgWithUselessDoubleConversion):
+ (JSC::B3::testCeilArgWithEffectfulDoubleConversion):
+ (JSC::B3::populateWithInterestingValues):
+ (JSC::B3::run):
+ * ftl/FTLB3Output.h:
+ (JSC::FTL::Output::ceil64):
+ * jit/ThunkGenerators.cpp:
+ (JSC::ceilThunkGenerator):
+
</ins><span class="cx"> 2015-12-14 Andreas Kling <akling@apple.com>
</span><span class="cx">
</span><span class="cx"> ResourceUsageOverlay should show GC timers.
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerARM64h"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARM64.h 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -1199,6 +1199,7 @@
</span><span class="cx"> static bool supportsFloatingPointTruncate() { return true; }
</span><span class="cx"> static bool supportsFloatingPointSqrt() { return true; }
</span><span class="cx"> static bool supportsFloatingPointAbs() { return true; }
</span><ins>+ static bool supportsFloatingPointCeil() { return true; }
</ins><span class="cx">
</span><span class="cx"> enum BranchTruncateType { BranchIfTruncateFailed, BranchIfTruncateSuccessful };
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerARMv7h"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerARMv7.h 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -856,6 +856,7 @@
</span><span class="cx"> static bool supportsFloatingPointTruncate() { return true; }
</span><span class="cx"> static bool supportsFloatingPointSqrt() { return true; }
</span><span class="cx"> static bool supportsFloatingPointAbs() { return true; }
</span><ins>+ static bool supportsFloatingPointCeil() { return false; }
</ins><span class="cx">
</span><span class="cx"> void loadDouble(ImplicitAddress address, FPRegisterID dest)
</span><span class="cx"> {
</span><span class="lines">@@ -1046,6 +1047,12 @@
</span><span class="cx"> m_assembler.vneg(dest, src);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ NO_RETURN_DUE_TO_CRASH void ceilDouble(FPRegisterID, FPRegisterID)
+ {
+ ASSERT(!supportsFloatingPointCeil());
+ CRASH();
+ }
+
</ins><span class="cx"> void convertInt32ToDouble(RegisterID src, FPRegisterID dest)
</span><span class="cx"> {
</span><span class="cx"> m_assembler.vmov(fpTempRegister, src, src);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerMIPSh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerMIPS.h 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -625,6 +625,12 @@
</span><span class="cx"> RELEASE_ASSERT_NOT_REACHED();
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ NO_RETURN_DUE_TO_CRASH void ceilDouble(FPRegisterID, FPRegisterID)
+ {
+ ASSERT(!supportsFloatingPointCeil());
+ CRASH();
+ }
+
</ins><span class="cx"> ConvertibleLoadLabel convertibleLoadPtr(Address address, RegisterID dest)
</span><span class="cx"> {
</span><span class="cx"> ConvertibleLoadLabel result(this);
</span><span class="lines">@@ -1209,6 +1215,7 @@
</span><span class="cx"> #endif
</span><span class="cx"> }
</span><span class="cx"> static bool supportsFloatingPointAbs() { return false; }
</span><ins>+ static bool supportsFloatingPointCeil() { return false; }
</ins><span class="cx">
</span><span class="cx"> // Stack manipulation operations:
</span><span class="cx"> //
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerSH4h"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerSH4.h (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerSH4.h 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerSH4.h 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -1091,6 +1091,7 @@
</span><span class="cx"> static bool supportsFloatingPointTruncate() { return true; }
</span><span class="cx"> static bool supportsFloatingPointSqrt() { return true; }
</span><span class="cx"> static bool supportsFloatingPointAbs() { return true; }
</span><ins>+ static bool supportsFloatingPointCeil() { return false; }
</ins><span class="cx">
</span><span class="cx"> void moveDoubleToInts(FPRegisterID src, RegisterID dest1, RegisterID dest2)
</span><span class="cx"> {
</span><span class="lines">@@ -1574,6 +1575,12 @@
</span><span class="cx"> m_assembler.dabs(dest);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ NO_RETURN_DUE_TO_CRASH void ceilDouble(FPRegisterID, FPRegisterID)
+ {
+ ASSERT(!supportsFloatingPointCeil());
+ CRASH();
+ }
+
</ins><span class="cx"> Jump branchTest8(ResultCondition cond, Address address, TrustedImm32 mask = TrustedImm32(-1))
</span><span class="cx"> {
</span><span class="cx"> RegisterID addressTempRegister = claimScratch();
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerX86Commoncpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.cpp (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.cpp 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.cpp 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -552,7 +552,8 @@
</span><span class="cx"> MacroAssemblerX86Common::SSE2CheckState MacroAssemblerX86Common::s_sse2CheckState = NotCheckedSSE2;
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>-MacroAssemblerX86Common::LZCNTCheckState MacroAssemblerX86Common::s_lzcntCheckState = LZCNTCheckState::NotChecked;
</del><ins>+MacroAssemblerX86Common::CPUIDCheckState MacroAssemblerX86Common::s_sse4_1CheckState = CPUIDCheckState::NotChecked;
+MacroAssemblerX86Common::CPUIDCheckState MacroAssemblerX86Common::s_lzcntCheckState = CPUIDCheckState::NotChecked;
</ins><span class="cx">
</span><span class="cx"> } // namespace JSC
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerMacroAssemblerX86Commonh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/assembler/MacroAssemblerX86Common.h 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -570,7 +570,26 @@
</span><span class="cx"> m_assembler.xorpd_rr(src, dst);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ void ceilDouble(FPRegisterID src, FPRegisterID dst)
+ {
+ m_assembler.roundsd_rr(src, dst, X86Assembler::RoundingType::TowardInfiniti);
+ }
</ins><span class="cx">
</span><ins>+ void ceilDouble(Address src, FPRegisterID dst)
+ {
+ m_assembler.roundsd_mr(src.offset, src.base, dst, X86Assembler::RoundingType::TowardInfiniti);
+ }
+
+ void ceilFloat(FPRegisterID src, FPRegisterID dst)
+ {
+ m_assembler.roundss_rr(src, dst, X86Assembler::RoundingType::TowardInfiniti);
+ }
+
+ void ceilFloat(Address src, FPRegisterID dst)
+ {
+ m_assembler.roundss_mr(src.offset, src.base, dst, X86Assembler::RoundingType::TowardInfiniti);
+ }
+
</ins><span class="cx"> // Memory access operations:
</span><span class="cx"> //
</span><span class="cx"> // Loads are of the form load(address, destination) and stores of the form
</span><span class="lines">@@ -1797,6 +1816,42 @@
</span><span class="cx"> return X86Assembler::maxJumpReplacementSize();
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ static bool supportsFloatingPointCeil()
+ {
+ if (s_sse4_1CheckState == CPUIDCheckState::NotChecked) {
+ int flags = 0;
+#if COMPILER(MSVC)
+ int cpuInfo[4];
+ __cpuid(cpuInfo, 0x1);
+ flags = cpuInfo[2];
+#elif COMPILER(GCC_OR_CLANG)
+#if CPU(X86_64)
+ asm (
+ "movl $0x1, %%eax;"
+ "cpuid;"
+ "movl %%ecx, %0;"
+ : "=g" (flags)
+ :
+ : "%eax", "%ebx", "%ecx", "%edx"
+ );
+#else
+ asm (
+ "movl $0x1, %%eax;"
+ "pushl %%ebx;"
+ "cpuid;"
+ "popl %%ebx;"
+ "movl %%ecx, %0;"
+ : "=g" (flags)
+ :
+ : "%eax", "%ecx", "%edx"
+ );
+#endif
+#endif // COMPILER(GCC_OR_CLANG)
+ s_sse4_1CheckState = (flags & (1 << 19)) ? CPUIDCheckState::Set : CPUIDCheckState::Clear;
+ }
+ return s_sse4_1CheckState == CPUIDCheckState::Set;
+ }
+
</ins><span class="cx"> #if ENABLE(MASM_PROBE)
</span><span class="cx"> void probe(ProbeFunction, void* arg1, void* arg2);
</span><span class="cx"> #endif // ENABLE(MASM_PROBE)
</span><span class="lines">@@ -1837,10 +1892,10 @@
</span><span class="cx"> m_assembler.cmovl_rr(cond, src, dest);
</span><span class="cx"> #endif
</span><span class="cx"> }
</span><del>-
</del><ins>+
</ins><span class="cx"> static bool supportsLZCNT()
</span><span class="cx"> {
</span><del>- if (s_lzcntCheckState == LZCNTCheckState::NotChecked) {
</del><ins>+ if (s_lzcntCheckState == CPUIDCheckState::NotChecked) {
</ins><span class="cx"> int flags = 0;
</span><span class="cx"> #if COMPILER(MSVC)
</span><span class="cx"> int cpuInfo[4];
</span><span class="lines">@@ -1869,9 +1924,9 @@
</span><span class="cx"> );
</span><span class="cx"> #endif
</span><span class="cx"> #endif // COMPILER(GCC_OR_CLANG)
</span><del>- s_lzcntCheckState = (flags & 0x20) ? LZCNTCheckState::Set : LZCNTCheckState::Clear;
</del><ins>+ s_lzcntCheckState = (flags & 0x20) ? CPUIDCheckState::Set : CPUIDCheckState::Clear;
</ins><span class="cx"> }
</span><del>- return s_lzcntCheckState == LZCNTCheckState::Set;
</del><ins>+ return s_lzcntCheckState == CPUIDCheckState::Set;
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> private:
</span><span class="lines">@@ -2041,12 +2096,13 @@
</span><span class="cx">
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- enum class LZCNTCheckState {
</del><ins>+ enum class CPUIDCheckState {
</ins><span class="cx"> NotChecked,
</span><span class="cx"> Clear,
</span><span class="cx"> Set
</span><span class="cx"> };
</span><del>- static LZCNTCheckState s_lzcntCheckState;
</del><ins>+ static CPUIDCheckState s_sse4_1CheckState;
+ static CPUIDCheckState s_lzcntCheckState;
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> } // namespace JSC
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreassemblerX86Assemblerh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/assembler/X86Assembler.h (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/assembler/X86Assembler.h 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/assembler/X86Assembler.h 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -264,6 +264,7 @@
</span><span class="cx"> OP2_CVTSI2SD_VsdEd = 0x2A,
</span><span class="cx"> OP2_CVTTSD2SI_GdWsd = 0x2C,
</span><span class="cx"> OP2_UCOMISD_VsdWsd = 0x2E,
</span><ins>+ OP2_3BYTE_ESCAPE_3A = 0x3A,
</ins><span class="cx"> OP2_CMOVCC = 0x40,
</span><span class="cx"> OP2_ADDSD_VsdWsd = 0x58,
</span><span class="cx"> OP2_MULSD_VsdWsd = 0x59,
</span><span class="lines">@@ -280,7 +281,7 @@
</span><span class="cx"> OP2_MOVD_EdVd = 0x7E,
</span><span class="cx"> OP2_JCC_rel32 = 0x80,
</span><span class="cx"> OP_SETCC = 0x90,
</span><del>- OP2_3BYTE_ESCAPE = 0xAE,
</del><ins>+ OP2_3BYTE_ESCAPE_AE = 0xAE,
</ins><span class="cx"> OP2_IMUL_GvEv = 0xAF,
</span><span class="cx"> OP2_MOVZX_GvEb = 0xB6,
</span><span class="cx"> OP2_BSR = 0xBD,
</span><span class="lines">@@ -295,7 +296,9 @@
</span><span class="cx"> } TwoByteOpcodeID;
</span><span class="cx">
</span><span class="cx"> typedef enum {
</span><del>- OP3_MFENCE = 0xF0,
</del><ins>+ OP3_ROUNDSS_VssWssIb = 0x0A,
+ OP3_ROUNDSD_VsdWsdIb = 0x0B,
+ OP3_MFENCE = 0xF0,
</ins><span class="cx"> } ThreeByteOpcodeID;
</span><span class="cx">
</span><span class="cx">
</span><span class="lines">@@ -2349,6 +2352,41 @@
</span><span class="cx"> m_formatter.twoByteOp(OP2_SQRTSD_VsdWsd, (RegisterID)dst, base, offset);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ enum class RoundingType : uint8_t {
+ ToNearestWithTiesToEven = 0,
+ TowardNegativeInfiniti = 1,
+ TowardInfiniti = 2,
+ TowardZero = 3
+ };
+
+ void roundss_rr(XMMRegisterID src, XMMRegisterID dst, RoundingType rounding)
+ {
+ m_formatter.prefix(PRE_SSE_66);
+ m_formatter.threeByteOp(OP2_3BYTE_ESCAPE_3A, OP3_ROUNDSS_VssWssIb, (RegisterID)dst, (RegisterID)src);
+ m_formatter.immediate8(static_cast<uint8_t>(rounding));
+ }
+
+ void roundss_mr(int offset, RegisterID base, XMMRegisterID dst, RoundingType rounding)
+ {
+ m_formatter.prefix(PRE_SSE_66);
+ m_formatter.threeByteOp(OP2_3BYTE_ESCAPE_3A, OP3_ROUNDSS_VssWssIb, (RegisterID)dst, base, offset);
+ m_formatter.immediate8(static_cast<uint8_t>(rounding));
+ }
+
+ void roundsd_rr(XMMRegisterID src, XMMRegisterID dst, RoundingType rounding)
+ {
+ m_formatter.prefix(PRE_SSE_66);
+ m_formatter.threeByteOp(OP2_3BYTE_ESCAPE_3A, OP3_ROUNDSD_VsdWsdIb, (RegisterID)dst, (RegisterID)src);
+ m_formatter.immediate8(static_cast<uint8_t>(rounding));
+ }
+
+ void roundsd_mr(int offset, RegisterID base, XMMRegisterID dst, RoundingType rounding)
+ {
+ m_formatter.prefix(PRE_SSE_66);
+ m_formatter.threeByteOp(OP2_3BYTE_ESCAPE_3A, OP3_ROUNDSD_VsdWsdIb, (RegisterID)dst, base, offset);
+ m_formatter.immediate8(static_cast<uint8_t>(rounding));
+ }
+
</ins><span class="cx"> // Misc instructions:
</span><span class="cx">
</span><span class="cx"> void int3()
</span><span class="lines">@@ -2368,7 +2406,7 @@
</span><span class="cx">
</span><span class="cx"> void mfence()
</span><span class="cx"> {
</span><del>- m_formatter.threeByteOp(OP3_MFENCE);
</del><ins>+ m_formatter.threeByteOp(OP2_3BYTE_ESCAPE_AE, OP3_MFENCE);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Assembler admin methods:
</span><span class="lines">@@ -2847,14 +2885,34 @@
</span><span class="cx"> }
</span><span class="cx"> #endif
</span><span class="cx">
</span><del>- void threeByteOp(ThreeByteOpcodeID opcode)
</del><ins>+ void threeByteOp(TwoByteOpcodeID twoBytePrefix, ThreeByteOpcodeID opcode)
</ins><span class="cx"> {
</span><span class="cx"> m_buffer.ensureSpace(maxInstructionSize);
</span><span class="cx"> m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);
</span><del>- m_buffer.putByteUnchecked(OP2_3BYTE_ESCAPE);
</del><ins>+ m_buffer.putByteUnchecked(twoBytePrefix);
</ins><span class="cx"> m_buffer.putByteUnchecked(opcode);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ void threeByteOp(TwoByteOpcodeID twoBytePrefix, ThreeByteOpcodeID opcode, int reg, RegisterID rm)
+ {
+ m_buffer.ensureSpace(maxInstructionSize);
+ emitRexIfNeeded(reg, 0, rm);
+ m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);
+ m_buffer.putByteUnchecked(twoBytePrefix);
+ m_buffer.putByteUnchecked(opcode);
+ registerModRM(reg, rm);
+ }
+
+ void threeByteOp(TwoByteOpcodeID twoBytePrefix, ThreeByteOpcodeID opcode, int reg, RegisterID base, int displacement)
+ {
+ m_buffer.ensureSpace(maxInstructionSize);
+ emitRexIfNeeded(reg, 0, base);
+ m_buffer.putByteUnchecked(OP_2BYTE_ESCAPE);
+ m_buffer.putByteUnchecked(twoBytePrefix);
+ m_buffer.putByteUnchecked(opcode);
+ memoryModRM(reg, base, displacement);
+ }
+
</ins><span class="cx"> #if CPU(X86_64)
</span><span class="cx"> // Quad-word-sized operands:
</span><span class="cx"> //
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3ConstDoubleValuecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.cpp (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.cpp 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.cpp 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -92,6 +92,11 @@
</span><span class="cx"> return proc.add<ConstDoubleValue>(origin(), fabs(m_value));
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+Value* ConstDoubleValue::ceilConstant(Procedure& proc) const
+{
+ return proc.add<ConstDoubleValue>(origin(), ceil(m_value));
+}
+
</ins><span class="cx"> Value* ConstDoubleValue::sqrtConstant(Procedure& proc) const
</span><span class="cx"> {
</span><span class="cx"> return proc.add<ConstDoubleValue>(origin(), sqrt(m_value));
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3ConstDoubleValueh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.h (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.h 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/b3/B3ConstDoubleValue.h 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -51,6 +51,7 @@
</span><span class="cx"> Value* bitwiseCastConstant(Procedure&) const override;
</span><span class="cx"> Value* doubleToFloatConstant(Procedure&) const override;
</span><span class="cx"> Value* absConstant(Procedure&) const override;
</span><ins>+ Value* ceilConstant(Procedure&) const override;
</ins><span class="cx"> Value* sqrtConstant(Procedure&) const override;
</span><span class="cx">
</span><span class="cx"> TriState equalConstant(const Value* other) const override;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3ConstFloatValuecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.cpp (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.cpp 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.cpp 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -92,6 +92,11 @@
</span><span class="cx"> return proc.add<ConstFloatValue>(origin(), static_cast<float>(fabs(m_value)));
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+Value* ConstFloatValue::ceilConstant(Procedure& proc) const
+{
+ return proc.add<ConstFloatValue>(origin(), ceilf(m_value));
+}
+
</ins><span class="cx"> Value* ConstFloatValue::sqrtConstant(Procedure& proc) const
</span><span class="cx"> {
</span><span class="cx"> return proc.add<ConstFloatValue>(origin(), static_cast<float>(sqrt(m_value)));
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3ConstFloatValueh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.h (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.h 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/b3/B3ConstFloatValue.h 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -50,6 +50,7 @@
</span><span class="cx"> Value* bitwiseCastConstant(Procedure&) const override;
</span><span class="cx"> Value* floatToDoubleConstant(Procedure&) const override;
</span><span class="cx"> Value* absConstant(Procedure&) const override;
</span><ins>+ Value* ceilConstant(Procedure&) const override;
</ins><span class="cx"> Value* sqrtConstant(Procedure&) const override;
</span><span class="cx">
</span><span class="cx"> TriState equalConstant(const Value* other) const override;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3LowerMacrosAfterOptimizationscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3LowerMacrosAfterOptimizations.cpp (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3LowerMacrosAfterOptimizations.cpp 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/b3/B3LowerMacrosAfterOptimizations.cpp 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -30,8 +30,10 @@
</span><span class="cx">
</span><span class="cx"> #include "B3BasicBlockInlines.h"
</span><span class="cx"> #include "B3BlockInsertionSet.h"
</span><ins>+#include "B3CCallValue.h"
</ins><span class="cx"> #include "B3ConstDoubleValue.h"
</span><span class="cx"> #include "B3ConstFloatValue.h"
</span><ins>+#include "B3ConstPtrValue.h"
</ins><span class="cx"> #include "B3InsertionSetInlines.h"
</span><span class="cx"> #include "B3PhaseScope.h"
</span><span class="cx">
</span><span class="lines">@@ -85,6 +87,27 @@
</span><span class="cx"> m_value->replaceWithIdentity(result);
</span><span class="cx"> break;
</span><span class="cx"> }
</span><ins>+ case Ceil: {
+ if (MacroAssembler::supportsFloatingPointCeil())
+ break;
+
+ Value* functionAddress = nullptr;
+ if (m_value->type() == Double)
+ functionAddress = m_insertionSet.insert<ConstPtrValue>(m_index, m_origin, ceil);
+ else if (m_value->type() == Float)
+ functionAddress = m_insertionSet.insert<ConstPtrValue>(m_index, m_origin, ceilf);
+ else
+ RELEASE_ASSERT_NOT_REACHED();
+
+ Value* result = m_insertionSet.insert<CCallValue>(m_index,
+ m_value->type(),
+ m_origin,
+ Effects::none(),
+ functionAddress,
+ m_value->child(0));
+ m_value->replaceWithIdentity(result);
+ break;
+ }
</ins><span class="cx"> default:
</span><span class="cx"> break;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3LowerToAircpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3LowerToAir.cpp (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3LowerToAir.cpp 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/b3/B3LowerToAir.cpp 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -1654,6 +1654,11 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ case Ceil: {
+ appendUnOp<Air::Oops, Air::Oops, CeilDouble, CeilFloat>(m_value->child(0));
+ return;
+ }
+
</ins><span class="cx"> case Sqrt: {
</span><span class="cx"> appendUnOp<Air::Oops, Air::Oops, SqrtDouble, SqrtFloat>(m_value->child(0));
</span><span class="cx"> return;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3Opcodecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3Opcode.cpp (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3Opcode.cpp 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/b3/B3Opcode.cpp 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -149,6 +149,9 @@
</span><span class="cx"> case Abs:
</span><span class="cx"> out.print("Abs");
</span><span class="cx"> return;
</span><ins>+ case Ceil:
+ out.print("Ceil");
+ return;
</ins><span class="cx"> case Sqrt:
</span><span class="cx"> out.print("Sqrt");
</span><span class="cx"> return;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3Opcodeh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3Opcode.h (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3Opcode.h 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/b3/B3Opcode.h 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -86,6 +86,7 @@
</span><span class="cx">
</span><span class="cx"> // Floating point math.
</span><span class="cx"> Abs,
</span><ins>+ Ceil,
</ins><span class="cx"> Sqrt,
</span><span class="cx">
</span><span class="cx"> // Casts and such.
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3ReduceDoubleToFloatcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3ReduceDoubleToFloat.cpp (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3ReduceDoubleToFloat.cpp 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/b3/B3ReduceDoubleToFloat.cpp 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -49,6 +49,7 @@
</span><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> case Abs:
</span><ins>+ case Ceil:
</ins><span class="cx"> case Sqrt:
</span><span class="cx"> if (candidate->child(0)->opcode() == FloatToDouble) {
</span><span class="cx"> candidate->child(0) = candidate->child(0)->child(0);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3ReduceStrengthcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3ReduceStrength.cpp (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3ReduceStrength.cpp 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/b3/B3ReduceStrength.cpp 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -564,6 +564,32 @@
</span><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx">
</span><ins>+ case Ceil:
+ // Turn this: Ceil(constant)
+ // Into this: ceil<value->type()>(constant)
+ if (Value* constant = m_value->child(0)->ceilConstant(m_proc)) {
+ replaceWithNewValue(constant);
+ break;
+ }
+
+ // Turn this: Ceil(Ceil(value))
+ // Into this: Ceil(value)
+ if (m_value->child(0)->opcode() == Ceil) {
+ m_value->replaceWithIdentity(m_value->child(0));
+ break;
+ }
+
+ // Turn this: Ceil(IToD(value))
+ // Into this: IToD(value)
+ //
+ // That works for Int64 because both ARM64 and x86_64
+ // perform rounding when converting a 64bit integer to double.
+ if (m_value->child(0)->opcode() == IToD) {
+ m_value->replaceWithIdentity(m_value->child(0));
+ break;
+ }
+ break;
+
</ins><span class="cx"> case Sqrt:
</span><span class="cx"> // Turn this: Sqrt(constant)
</span><span class="cx"> // Into this: sqrt<value->type()>(constant)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3Validatecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3Validate.cpp (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3Validate.cpp 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/b3/B3Validate.cpp 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -210,6 +210,7 @@
</span><span class="cx"> VALIDATE(value->type() == Int32, ("At ", *value));
</span><span class="cx"> break;
</span><span class="cx"> case Abs:
</span><ins>+ case Ceil:
</ins><span class="cx"> case Sqrt:
</span><span class="cx"> VALIDATE(value->numChildren() == 1, ("At ", *value));
</span><span class="cx"> VALIDATE(isFloat(value->child(0)->type()), ("At ", *value));
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3Valuecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3Value.cpp (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3Value.cpp 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/b3/B3Value.cpp 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -226,6 +226,11 @@
</span><span class="cx"> return nullptr;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+Value* Value::ceilConstant(Procedure&) const
+{
+ return nullptr;
+}
+
</ins><span class="cx"> Value* Value::sqrtConstant(Procedure&) const
</span><span class="cx"> {
</span><span class="cx"> return nullptr;
</span><span class="lines">@@ -363,6 +368,7 @@
</span><span class="cx"> case ZShr:
</span><span class="cx"> case Clz:
</span><span class="cx"> case Abs:
</span><ins>+ case Ceil:
</ins><span class="cx"> case Sqrt:
</span><span class="cx"> case BitwiseCast:
</span><span class="cx"> case SExt8:
</span><span class="lines">@@ -442,6 +448,7 @@
</span><span class="cx"> return ValueKey(opcode(), type());
</span><span class="cx"> case Identity:
</span><span class="cx"> case Abs:
</span><ins>+ case Ceil:
</ins><span class="cx"> case Sqrt:
</span><span class="cx"> case SExt8:
</span><span class="cx"> case SExt16:
</span><span class="lines">@@ -549,6 +556,7 @@
</span><span class="cx"> case ZShr:
</span><span class="cx"> case Clz:
</span><span class="cx"> case Abs:
</span><ins>+ case Ceil:
</ins><span class="cx"> case Sqrt:
</span><span class="cx"> case CheckAdd:
</span><span class="cx"> case CheckSub:
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3B3Valueh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/B3Value.h (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/B3Value.h 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/b3/B3Value.h 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -132,6 +132,7 @@
</span><span class="cx"> virtual Value* doubleToFloatConstant(Procedure&) const;
</span><span class="cx"> virtual Value* floatToDoubleConstant(Procedure&) const;
</span><span class="cx"> virtual Value* absConstant(Procedure&) const;
</span><ins>+ virtual Value* ceilConstant(Procedure&) const;
</ins><span class="cx"> virtual Value* sqrtConstant(Procedure&) const;
</span><span class="cx">
</span><span class="cx"> virtual TriState equalConstant(const Value* other) const;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3airAirOpcodeopcodes"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/air/AirOpcode.opcodes (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/air/AirOpcode.opcodes 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/b3/air/AirOpcode.opcodes 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -275,6 +275,14 @@
</span><span class="cx"> Tmp
</span><span class="cx"> x86: Addr
</span><span class="cx">
</span><ins>+CeilDouble U:F, UD:F
+ Tmp, Tmp
+ Addr, Tmp
+
+CeilFloat U:F, UD:F
+ Tmp, Tmp
+ Addr, Tmp
+
</ins><span class="cx"> SqrtDouble U:F, UD:F
</span><span class="cx"> Tmp, Tmp
</span><span class="cx"> x86: Addr, Tmp
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreb3testb3cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/b3/testb3.cpp (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/b3/testb3.cpp 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/b3/testb3.cpp 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -3235,6 +3235,175 @@
</span><span class="cx"> CHECK(isIdentical(effect, fabs(a)));
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+void testCeilArg(double a)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ root->appendNew<ControlValue>(
+ proc, Return, Origin(),
+ root->appendNew<Value>(
+ proc, Ceil, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0)));
+
+ CHECK(isIdentical(compileAndRun<double>(proc, a), ceil(a)));
+}
+
+void testCeilImm(double a)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argument = root->appendNew<ConstDoubleValue>(proc, Origin(), a);
+ root->appendNew<ControlValue>(
+ proc, Return, Origin(),
+ root->appendNew<Value>(proc, Ceil, Origin(), argument));
+
+ CHECK(isIdentical(compileAndRun<double>(proc), ceil(a)));
+}
+
+void testCeilMem(double a)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
+ MemoryValue* loadDouble = root->appendNew<MemoryValue>(proc, Load, Double, Origin(), address);
+ root->appendNew<ControlValue>(
+ proc, Return, Origin(),
+ root->appendNew<Value>(proc, Ceil, Origin(), loadDouble));
+
+ CHECK(isIdentical(compileAndRun<double>(proc, &a), ceil(a)));
+}
+
+void testCeilCeilArg(double a)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* firstCeil = root->appendNew<Value>(proc, Ceil, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), FPRInfo::argumentFPR0));
+ Value* secondCeil = root->appendNew<Value>(proc, Ceil, Origin(), firstCeil);
+ root->appendNew<ControlValue>(proc, Return, Origin(), secondCeil);
+
+ CHECK(isIdentical(compileAndRun<double>(proc, a), ceil(a)));
+}
+
+void testCeilIToD64(int64_t a)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argument = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
+ Value* argumentAsDouble = root->appendNew<Value>(proc, IToD, Origin(), argument);
+
+ root->appendNew<ControlValue>(
+ proc, Return, Origin(),
+ root->appendNew<Value>(proc, Ceil, Origin(), argumentAsDouble));
+
+ CHECK(isIdentical(compileAndRun<double>(proc, a), ceil(static_cast<double>(a))));
+}
+
+void testCeilIToD32(int64_t a)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argument = root->appendNew<Value>(proc, Trunc, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
+ Value* argumentAsDouble = root->appendNew<Value>(proc, IToD, Origin(), argument);
+
+ root->appendNew<ControlValue>(
+ proc, Return, Origin(),
+ root->appendNew<Value>(proc, Ceil, Origin(), argumentAsDouble));
+
+ CHECK(isIdentical(compileAndRun<double>(proc, a), ceil(static_cast<double>(a))));
+}
+
+void testCeilArg(float a)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argument32 = root->appendNew<Value>(proc, Trunc, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
+ Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
+ Value* result = root->appendNew<Value>(proc, Ceil, Origin(), argument);
+ Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
+ root->appendNew<ControlValue>(proc, Return, Origin(), result32);
+
+ CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(ceilf(a))));
+}
+
+void testCeilImm(float a)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argument = root->appendNew<ConstFloatValue>(proc, Origin(), a);
+ Value* result = root->appendNew<Value>(proc, Ceil, Origin(), argument);
+ Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
+ root->appendNew<ControlValue>(proc, Return, Origin(), result32);
+
+ CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(ceilf(a))));
+}
+
+void testCeilMem(float a)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* address = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0);
+ MemoryValue* loadFloat = root->appendNew<MemoryValue>(proc, Load, Float, Origin(), address);
+ Value* result = root->appendNew<Value>(proc, Ceil, Origin(), loadFloat);
+ Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), result);
+ root->appendNew<ControlValue>(proc, Return, Origin(), result32);
+
+ CHECK(isIdentical(compileAndRun<int32_t>(proc, &a), bitwise_cast<int32_t>(ceilf(a))));
+}
+
+void testCeilCeilArg(float a)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argument32 = root->appendNew<Value>(proc, Trunc, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
+ Value* argument = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
+ Value* firstCeil = root->appendNew<Value>(proc, Ceil, Origin(), argument);
+ Value* secondCeil = root->appendNew<Value>(proc, Ceil, Origin(), firstCeil);
+ root->appendNew<ControlValue>(proc, Return, Origin(), secondCeil);
+
+ CHECK(isIdentical(compileAndRun<float>(proc, bitwise_cast<int32_t>(a)), ceilf(a)));
+}
+
+void testCeilArgWithUselessDoubleConversion(float a)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argument32 = root->appendNew<Value>(proc, Trunc, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
+ Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
+ Value* asDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue);
+ Value* result = root->appendNew<Value>(proc, Ceil, Origin(), asDouble);
+ Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);
+ Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
+ root->appendNew<ControlValue>(proc, Return, Origin(), result32);
+
+ CHECK(isIdentical(compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a)), bitwise_cast<int32_t>(ceilf(a))));
+}
+
+void testCeilArgWithEffectfulDoubleConversion(float a)
+{
+ Procedure proc;
+ BasicBlock* root = proc.addBlock();
+ Value* argument32 = root->appendNew<Value>(proc, Trunc, Origin(),
+ root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR0));
+ Value* floatValue = root->appendNew<Value>(proc, BitwiseCast, Origin(), argument32);
+ Value* asDouble = root->appendNew<Value>(proc, FloatToDouble, Origin(), floatValue);
+ Value* result = root->appendNew<Value>(proc, Ceil, Origin(), asDouble);
+ Value* floatResult = root->appendNew<Value>(proc, DoubleToFloat, Origin(), result);
+ Value* result32 = root->appendNew<Value>(proc, BitwiseCast, Origin(), floatResult);
+ Value* doubleAddress = root->appendNew<ArgumentRegValue>(proc, Origin(), GPRInfo::argumentGPR1);
+ root->appendNew<MemoryValue>(proc, Store, Origin(), result, doubleAddress);
+ root->appendNew<ControlValue>(proc, Return, Origin(), result32);
+
+ double effect = 0;
+ int32_t resultValue = compileAndRun<int32_t>(proc, bitwise_cast<int32_t>(a), &effect);
+ CHECK(isIdentical(resultValue, bitwise_cast<int32_t>(ceilf(a))));
+ CHECK(isIdentical(effect, ceilf(a)));
+}
+
</ins><span class="cx"> void testSqrtArg(double a)
</span><span class="cx"> {
</span><span class="cx"> Procedure proc;
</span><span class="lines">@@ -8008,6 +8177,12 @@
</span><span class="cx"> {
</span><span class="cx"> operands.append({ "0.", static_cast<FloatType>(0.) });
</span><span class="cx"> operands.append({ "-0.", static_cast<FloatType>(-0.) });
</span><ins>+ operands.append({ "0.4", static_cast<FloatType>(0.5) });
+ operands.append({ "-0.4", static_cast<FloatType>(-0.5) });
+ operands.append({ "0.5", static_cast<FloatType>(0.5) });
+ operands.append({ "-0.5", static_cast<FloatType>(-0.5) });
+ operands.append({ "0.6", static_cast<FloatType>(0.5) });
+ operands.append({ "-0.6", static_cast<FloatType>(-0.5) });
</ins><span class="cx"> operands.append({ "1.", static_cast<FloatType>(1.) });
</span><span class="cx"> operands.append({ "-1.", static_cast<FloatType>(-1.) });
</span><span class="cx"> operands.append({ "2.", static_cast<FloatType>(2.) });
</span><span class="lines">@@ -8638,6 +8813,19 @@
</span><span class="cx"> RUN_UNARY(testAbsArgWithUselessDoubleConversion, floatingPointOperands<float>());
</span><span class="cx"> RUN_UNARY(testAbsArgWithEffectfulDoubleConversion, floatingPointOperands<float>());
</span><span class="cx">
</span><ins>+ RUN_UNARY(testCeilArg, floatingPointOperands<double>());
+ RUN_UNARY(testCeilImm, floatingPointOperands<double>());
+ RUN_UNARY(testCeilMem, floatingPointOperands<double>());
+ RUN_UNARY(testCeilCeilArg, floatingPointOperands<double>());
+ RUN_UNARY(testCeilIToD64, int64Operands());
+ RUN_UNARY(testCeilIToD32, int32Operands());
+ RUN_UNARY(testCeilArg, floatingPointOperands<float>());
+ RUN_UNARY(testCeilImm, floatingPointOperands<float>());
+ RUN_UNARY(testCeilMem, floatingPointOperands<float>());
+ RUN_UNARY(testCeilCeilArg, floatingPointOperands<float>());
+ RUN_UNARY(testCeilArgWithUselessDoubleConversion, floatingPointOperands<float>());
+ RUN_UNARY(testCeilArgWithEffectfulDoubleConversion, floatingPointOperands<float>());
+
</ins><span class="cx"> RUN_UNARY(testSqrtArg, floatingPointOperands<double>());
</span><span class="cx"> RUN_UNARY(testSqrtImm, floatingPointOperands<double>());
</span><span class="cx"> RUN_UNARY(testSqrtMem, floatingPointOperands<double>());
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLB3Outputh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLB3Output.h (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLB3Output.h 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/ftl/FTLB3Output.h 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -154,7 +154,7 @@
</span><span class="cx"> LValue lShr(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::ZShr, origin(), left, castToInt32(right)); }
</span><span class="cx"> LValue bitNot(LValue);
</span><span class="cx">
</span><del>- LValue ceil64(LValue operand) { CRASH(); }
</del><ins>+ LValue ceil64(LValue operand) { return m_block->appendNew<B3::Value>(m_proc, B3::Ceil, origin(), value); }
</ins><span class="cx"> LValue ctlz32(LValue operand) { return m_block->appendNew<B3::Value>(m_proc, B3::Clz, origin(), operand); }
</span><span class="cx"> LValue addWithOverflow32(LValue left, LValue right) { CRASH(); }
</span><span class="cx"> LValue subWithOverflow32(LValue left, LValue right) { CRASH(); }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitThunkGeneratorscpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp (194061 => 194062)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp 2015-12-14 22:26:40 UTC (rev 194061)
+++ trunk/Source/JavaScriptCore/jit/ThunkGenerators.cpp 2015-12-14 22:44:22 UTC (rev 194062)
</span><span class="lines">@@ -828,11 +828,11 @@
</span><span class="cx"> jit.returnInt32(SpecializedThunkJIT::regT0);
</span><span class="cx"> nonIntJump.link(&jit);
</span><span class="cx"> jit.loadDoubleArgument(0, SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::regT0);
</span><del>-#if CPU(ARM64)
- jit.ceilDouble(SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::fpRegT0);
-#else
- jit.callDoubleToDoublePreservingReturn(UnaryDoubleOpWrapper(ceil));
-#endif // CPU(ARM64)
</del><ins>+ if (jit.supportsFloatingPointCeil())
+ jit.ceilDouble(SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::fpRegT0);
+ else
+ jit.callDoubleToDoublePreservingReturn(UnaryDoubleOpWrapper(ceil));
+
</ins><span class="cx"> SpecializedThunkJIT::JumpList doubleResult;
</span><span class="cx"> jit.branchConvertDoubleToInt32(SpecializedThunkJIT::fpRegT0, SpecializedThunkJIT::regT0, doubleResult, SpecializedThunkJIT::fpRegT1);
</span><span class="cx"> jit.returnInt32(SpecializedThunkJIT::regT0);
</span></span></pre>
</div>
</div>
</body>
</html>