<!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>[202007] 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/202007">202007</a></dd>
<dt>Author</dt> <dd>fpizlo@apple.com</dd>
<dt>Date</dt> <dd>2016-06-13 15:17:50 -0700 (Mon, 13 Jun 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>FTL::Output methods should be out-of-line whenever possible
https://bugs.webkit.org/show_bug.cgi?id=158704
Reviewed by Benjamin Poulain.
These methods turn into a non-trivial amount of code because of the template-based B3 API.
Inlining them didn't achieve any performance advantages for the FTL, but it did make the
code larger. This outlines most methods in FTL::Output. It makes FTL::LowerDFGToB3 smaller
and it doesn't change performance.
* ftl/FTLOutput.cpp:
(JSC::FTL::Output::appendTo):
(JSC::FTL::Output::framePointer):
(JSC::FTL::Output::lockedStackSlot):
(JSC::FTL::Output::constBool):
(JSC::FTL::Output::constInt32):
(JSC::FTL::Output::constInt64):
(JSC::FTL::Output::constDouble):
(JSC::FTL::Output::phi):
(JSC::FTL::Output::add):
(JSC::FTL::Output::sub):
(JSC::FTL::Output::mul):
(JSC::FTL::Output::div):
(JSC::FTL::Output::chillDiv):
(JSC::FTL::Output::mod):
(JSC::FTL::Output::chillMod):
(JSC::FTL::Output::neg):
(JSC::FTL::Output::doubleAdd):
(JSC::FTL::Output::doubleSub):
(JSC::FTL::Output::doubleMul):
(JSC::FTL::Output::doubleDiv):
(JSC::FTL::Output::doubleMod):
(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::logicalNot):
(JSC::FTL::Output::ctlz32):
(JSC::FTL::Output::doubleAbs):
(JSC::FTL::Output::doubleCeil):
(JSC::FTL::Output::doubleFloor):
(JSC::FTL::Output::doubleTrunc):
(JSC::FTL::Output::doubleSin):
(JSC::FTL::Output::doubleCos):
(JSC::FTL::Output::doublePow):
(JSC::FTL::Output::doublePowi):
(JSC::FTL::Output::doubleSqrt):
(JSC::FTL::Output::doubleLog):
(JSC::FTL::Output::hasSensibleDoubleToInt):
(JSC::FTL::Output::doubleToUInt):
(JSC::FTL::Output::signExt32To64):
(JSC::FTL::Output::zeroExt):
(JSC::FTL::Output::intToDouble):
(JSC::FTL::Output::unsignedToDouble):
(JSC::FTL::Output::castToInt32):
(JSC::FTL::Output::doubleToFloat):
(JSC::FTL::Output::floatToDouble):
(JSC::FTL::Output::load):
(JSC::FTL::Output::load8SignExt32):
(JSC::FTL::Output::baseIndex):
(JSC::FTL::Output::equal):
(JSC::FTL::Output::notEqual):
(JSC::FTL::Output::above):
(JSC::FTL::Output::aboveOrEqual):
(JSC::FTL::Output::below):
(JSC::FTL::Output::belowOrEqual):
(JSC::FTL::Output::greaterThan):
(JSC::FTL::Output::greaterThanOrEqual):
(JSC::FTL::Output::lessThan):
(JSC::FTL::Output::lessThanOrEqual):
(JSC::FTL::Output::doubleEqual):
(JSC::FTL::Output::doubleEqualOrUnordered):
(JSC::FTL::Output::doubleNotEqualOrUnordered):
(JSC::FTL::Output::doubleLessThan):
(JSC::FTL::Output::doubleLessThanOrEqual):
(JSC::FTL::Output::doubleGreaterThan):
(JSC::FTL::Output::doubleGreaterThanOrEqual):
(JSC::FTL::Output::doubleNotEqualAndOrdered):
(JSC::FTL::Output::doubleLessThanOrUnordered):
(JSC::FTL::Output::doubleLessThanOrEqualOrUnordered):
(JSC::FTL::Output::doubleGreaterThanOrUnordered):
(JSC::FTL::Output::doubleGreaterThanOrEqualOrUnordered):
(JSC::FTL::Output::isZero32):
(JSC::FTL::Output::notZero32):
(JSC::FTL::Output::isZero64):
(JSC::FTL::Output::notZero64):
(JSC::FTL::Output::select):
(JSC::FTL::Output::jump):
(JSC::FTL::Output::branch):
(JSC::FTL::Output::check):
(JSC::FTL::Output::ret):
(JSC::FTL::Output::unreachable):
(JSC::FTL::Output::speculate):
(JSC::FTL::Output::speculateAdd):
(JSC::FTL::Output::speculateSub):
(JSC::FTL::Output::speculateMul):
(JSC::FTL::Output::patchpoint):
(JSC::FTL::Output::trap):
(JSC::FTL::Output::anchor):
(JSC::FTL::Output::bitCast):
(JSC::FTL::Output::fround):
* ftl/FTLOutput.h:
(JSC::FTL::Output::setOrigin):
(JSC::FTL::Output::origin):
(JSC::FTL::Output::constIntPtr):
(JSC::FTL::Output::doubleNeg):
(JSC::FTL::Output::zeroExtPtr):
(JSC::FTL::Output::load32NonNegative):
(JSC::FTL::Output::isNull):
(JSC::FTL::Output::notNull):
(JSC::FTL::Output::testIsZeroPtr):
(JSC::FTL::Output::testNonZeroPtr):
(JSC::FTL::Output::call):
(JSC::FTL::Output::operation):
(JSC::FTL::Output::branch):
(JSC::FTL::Output::switchInstruction):
(JSC::FTL::Output::addIncomingToPhi):
(JSC::FTL::Output::framePointer): Deleted.
(JSC::FTL::Output::constBool): Deleted.
(JSC::FTL::Output::constInt32): Deleted.
(JSC::FTL::Output::constInt64): Deleted.
(JSC::FTL::Output::constDouble): Deleted.
(JSC::FTL::Output::phi): Deleted.
(JSC::FTL::Output::add): Deleted.
(JSC::FTL::Output::sub): Deleted.
(JSC::FTL::Output::mul): Deleted.
(JSC::FTL::Output::div): Deleted.
(JSC::FTL::Output::chillDiv): Deleted.
(JSC::FTL::Output::mod): Deleted.
(JSC::FTL::Output::chillMod): Deleted.
(JSC::FTL::Output::doubleAdd): Deleted.
(JSC::FTL::Output::doubleSub): Deleted.
(JSC::FTL::Output::doubleMul): Deleted.
(JSC::FTL::Output::doubleDiv): Deleted.
(JSC::FTL::Output::doubleMod): Deleted.
(JSC::FTL::Output::bitAnd): Deleted.
(JSC::FTL::Output::bitOr): Deleted.
(JSC::FTL::Output::bitXor): Deleted.
(JSC::FTL::Output::shl): Deleted.
(JSC::FTL::Output::aShr): Deleted.
(JSC::FTL::Output::lShr): Deleted.
(JSC::FTL::Output::ctlz32): Deleted.
(JSC::FTL::Output::addWithOverflow32): Deleted.
(JSC::FTL::Output::subWithOverflow32): Deleted.
(JSC::FTL::Output::mulWithOverflow32): Deleted.
(JSC::FTL::Output::addWithOverflow64): Deleted.
(JSC::FTL::Output::subWithOverflow64): Deleted.
(JSC::FTL::Output::mulWithOverflow64): Deleted.
(JSC::FTL::Output::doubleAbs): Deleted.
(JSC::FTL::Output::doubleCeil): Deleted.
(JSC::FTL::Output::doubleFloor): Deleted.
(JSC::FTL::Output::doubleSin): Deleted.
(JSC::FTL::Output::doubleCos): Deleted.
(JSC::FTL::Output::doublePow): Deleted.
(JSC::FTL::Output::doubleSqrt): Deleted.
(JSC::FTL::Output::doubleLog): Deleted.
(JSC::FTL::Output::signExt32To64): Deleted.
(JSC::FTL::Output::zeroExt): Deleted.
(JSC::FTL::Output::intToDouble): Deleted.
(JSC::FTL::Output::castToInt32): Deleted.
(JSC::FTL::Output::doubleToFloat): Deleted.
(JSC::FTL::Output::floatToDouble): Deleted.
(JSC::FTL::Output::equal): Deleted.
(JSC::FTL::Output::notEqual): Deleted.
(JSC::FTL::Output::above): Deleted.
(JSC::FTL::Output::aboveOrEqual): Deleted.
(JSC::FTL::Output::below): Deleted.
(JSC::FTL::Output::belowOrEqual): Deleted.
(JSC::FTL::Output::greaterThan): Deleted.
(JSC::FTL::Output::greaterThanOrEqual): Deleted.
(JSC::FTL::Output::lessThan): Deleted.
(JSC::FTL::Output::lessThanOrEqual): Deleted.
(JSC::FTL::Output::doubleEqual): Deleted.
(JSC::FTL::Output::doubleEqualOrUnordered): Deleted.
(JSC::FTL::Output::doubleNotEqualOrUnordered): Deleted.
(JSC::FTL::Output::doubleLessThan): Deleted.
(JSC::FTL::Output::doubleLessThanOrEqual): Deleted.
(JSC::FTL::Output::doubleGreaterThan): Deleted.
(JSC::FTL::Output::doubleGreaterThanOrEqual): Deleted.
(JSC::FTL::Output::doubleNotEqualAndOrdered): Deleted.
(JSC::FTL::Output::doubleLessThanOrUnordered): Deleted.
(JSC::FTL::Output::doubleLessThanOrEqualOrUnordered): Deleted.
(JSC::FTL::Output::doubleGreaterThanOrUnordered): Deleted.
(JSC::FTL::Output::doubleGreaterThanOrEqualOrUnordered): Deleted.
(JSC::FTL::Output::isZero32): Deleted.
(JSC::FTL::Output::notZero32): Deleted.
(JSC::FTL::Output::isZero64): Deleted.
(JSC::FTL::Output::notZero64): Deleted.
(JSC::FTL::Output::select): Deleted.
(JSC::FTL::Output::extractValue): Deleted.
(JSC::FTL::Output::jump): Deleted.
(JSC::FTL::Output::ret): Deleted.
(JSC::FTL::Output::unreachable): Deleted.
(JSC::FTL::Output::speculate): Deleted.
(JSC::FTL::Output::speculateAdd): Deleted.
(JSC::FTL::Output::speculateSub): Deleted.
(JSC::FTL::Output::speculateMul): Deleted.
(JSC::FTL::Output::patchpoint): Deleted.
(JSC::FTL::Output::trap): Deleted.
(JSC::FTL::Output::anchor): Deleted.
(JSC::FTL::Output::bitCast): Deleted.
(JSC::FTL::Output::fround): Deleted.</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLOutputcpp">trunk/Source/JavaScriptCore/ftl/FTLOutput.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 (202006 => 202007)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2016-06-13 22:00:49 UTC (rev 202006)
+++ trunk/Source/JavaScriptCore/ChangeLog 2016-06-13 22:17:50 UTC (rev 202007)
</span><span class="lines">@@ -1,3 +1,211 @@
</span><ins>+2016-06-13 Filip Pizlo <fpizlo@apple.com>
+
+ FTL::Output methods should be out-of-line whenever possible
+ https://bugs.webkit.org/show_bug.cgi?id=158704
+
+ Reviewed by Benjamin Poulain.
+
+ These methods turn into a non-trivial amount of code because of the template-based B3 API.
+ Inlining them didn't achieve any performance advantages for the FTL, but it did make the
+ code larger. This outlines most methods in FTL::Output. It makes FTL::LowerDFGToB3 smaller
+ and it doesn't change performance.
+
+ * ftl/FTLOutput.cpp:
+ (JSC::FTL::Output::appendTo):
+ (JSC::FTL::Output::framePointer):
+ (JSC::FTL::Output::lockedStackSlot):
+ (JSC::FTL::Output::constBool):
+ (JSC::FTL::Output::constInt32):
+ (JSC::FTL::Output::constInt64):
+ (JSC::FTL::Output::constDouble):
+ (JSC::FTL::Output::phi):
+ (JSC::FTL::Output::add):
+ (JSC::FTL::Output::sub):
+ (JSC::FTL::Output::mul):
+ (JSC::FTL::Output::div):
+ (JSC::FTL::Output::chillDiv):
+ (JSC::FTL::Output::mod):
+ (JSC::FTL::Output::chillMod):
+ (JSC::FTL::Output::neg):
+ (JSC::FTL::Output::doubleAdd):
+ (JSC::FTL::Output::doubleSub):
+ (JSC::FTL::Output::doubleMul):
+ (JSC::FTL::Output::doubleDiv):
+ (JSC::FTL::Output::doubleMod):
+ (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::logicalNot):
+ (JSC::FTL::Output::ctlz32):
+ (JSC::FTL::Output::doubleAbs):
+ (JSC::FTL::Output::doubleCeil):
+ (JSC::FTL::Output::doubleFloor):
+ (JSC::FTL::Output::doubleTrunc):
+ (JSC::FTL::Output::doubleSin):
+ (JSC::FTL::Output::doubleCos):
+ (JSC::FTL::Output::doublePow):
+ (JSC::FTL::Output::doublePowi):
+ (JSC::FTL::Output::doubleSqrt):
+ (JSC::FTL::Output::doubleLog):
+ (JSC::FTL::Output::hasSensibleDoubleToInt):
+ (JSC::FTL::Output::doubleToUInt):
+ (JSC::FTL::Output::signExt32To64):
+ (JSC::FTL::Output::zeroExt):
+ (JSC::FTL::Output::intToDouble):
+ (JSC::FTL::Output::unsignedToDouble):
+ (JSC::FTL::Output::castToInt32):
+ (JSC::FTL::Output::doubleToFloat):
+ (JSC::FTL::Output::floatToDouble):
+ (JSC::FTL::Output::load):
+ (JSC::FTL::Output::load8SignExt32):
+ (JSC::FTL::Output::baseIndex):
+ (JSC::FTL::Output::equal):
+ (JSC::FTL::Output::notEqual):
+ (JSC::FTL::Output::above):
+ (JSC::FTL::Output::aboveOrEqual):
+ (JSC::FTL::Output::below):
+ (JSC::FTL::Output::belowOrEqual):
+ (JSC::FTL::Output::greaterThan):
+ (JSC::FTL::Output::greaterThanOrEqual):
+ (JSC::FTL::Output::lessThan):
+ (JSC::FTL::Output::lessThanOrEqual):
+ (JSC::FTL::Output::doubleEqual):
+ (JSC::FTL::Output::doubleEqualOrUnordered):
+ (JSC::FTL::Output::doubleNotEqualOrUnordered):
+ (JSC::FTL::Output::doubleLessThan):
+ (JSC::FTL::Output::doubleLessThanOrEqual):
+ (JSC::FTL::Output::doubleGreaterThan):
+ (JSC::FTL::Output::doubleGreaterThanOrEqual):
+ (JSC::FTL::Output::doubleNotEqualAndOrdered):
+ (JSC::FTL::Output::doubleLessThanOrUnordered):
+ (JSC::FTL::Output::doubleLessThanOrEqualOrUnordered):
+ (JSC::FTL::Output::doubleGreaterThanOrUnordered):
+ (JSC::FTL::Output::doubleGreaterThanOrEqualOrUnordered):
+ (JSC::FTL::Output::isZero32):
+ (JSC::FTL::Output::notZero32):
+ (JSC::FTL::Output::isZero64):
+ (JSC::FTL::Output::notZero64):
+ (JSC::FTL::Output::select):
+ (JSC::FTL::Output::jump):
+ (JSC::FTL::Output::branch):
+ (JSC::FTL::Output::check):
+ (JSC::FTL::Output::ret):
+ (JSC::FTL::Output::unreachable):
+ (JSC::FTL::Output::speculate):
+ (JSC::FTL::Output::speculateAdd):
+ (JSC::FTL::Output::speculateSub):
+ (JSC::FTL::Output::speculateMul):
+ (JSC::FTL::Output::patchpoint):
+ (JSC::FTL::Output::trap):
+ (JSC::FTL::Output::anchor):
+ (JSC::FTL::Output::bitCast):
+ (JSC::FTL::Output::fround):
+ * ftl/FTLOutput.h:
+ (JSC::FTL::Output::setOrigin):
+ (JSC::FTL::Output::origin):
+ (JSC::FTL::Output::constIntPtr):
+ (JSC::FTL::Output::doubleNeg):
+ (JSC::FTL::Output::zeroExtPtr):
+ (JSC::FTL::Output::load32NonNegative):
+ (JSC::FTL::Output::isNull):
+ (JSC::FTL::Output::notNull):
+ (JSC::FTL::Output::testIsZeroPtr):
+ (JSC::FTL::Output::testNonZeroPtr):
+ (JSC::FTL::Output::call):
+ (JSC::FTL::Output::operation):
+ (JSC::FTL::Output::branch):
+ (JSC::FTL::Output::switchInstruction):
+ (JSC::FTL::Output::addIncomingToPhi):
+ (JSC::FTL::Output::framePointer): Deleted.
+ (JSC::FTL::Output::constBool): Deleted.
+ (JSC::FTL::Output::constInt32): Deleted.
+ (JSC::FTL::Output::constInt64): Deleted.
+ (JSC::FTL::Output::constDouble): Deleted.
+ (JSC::FTL::Output::phi): Deleted.
+ (JSC::FTL::Output::add): Deleted.
+ (JSC::FTL::Output::sub): Deleted.
+ (JSC::FTL::Output::mul): Deleted.
+ (JSC::FTL::Output::div): Deleted.
+ (JSC::FTL::Output::chillDiv): Deleted.
+ (JSC::FTL::Output::mod): Deleted.
+ (JSC::FTL::Output::chillMod): Deleted.
+ (JSC::FTL::Output::doubleAdd): Deleted.
+ (JSC::FTL::Output::doubleSub): Deleted.
+ (JSC::FTL::Output::doubleMul): Deleted.
+ (JSC::FTL::Output::doubleDiv): Deleted.
+ (JSC::FTL::Output::doubleMod): Deleted.
+ (JSC::FTL::Output::bitAnd): Deleted.
+ (JSC::FTL::Output::bitOr): Deleted.
+ (JSC::FTL::Output::bitXor): Deleted.
+ (JSC::FTL::Output::shl): Deleted.
+ (JSC::FTL::Output::aShr): Deleted.
+ (JSC::FTL::Output::lShr): Deleted.
+ (JSC::FTL::Output::ctlz32): Deleted.
+ (JSC::FTL::Output::addWithOverflow32): Deleted.
+ (JSC::FTL::Output::subWithOverflow32): Deleted.
+ (JSC::FTL::Output::mulWithOverflow32): Deleted.
+ (JSC::FTL::Output::addWithOverflow64): Deleted.
+ (JSC::FTL::Output::subWithOverflow64): Deleted.
+ (JSC::FTL::Output::mulWithOverflow64): Deleted.
+ (JSC::FTL::Output::doubleAbs): Deleted.
+ (JSC::FTL::Output::doubleCeil): Deleted.
+ (JSC::FTL::Output::doubleFloor): Deleted.
+ (JSC::FTL::Output::doubleSin): Deleted.
+ (JSC::FTL::Output::doubleCos): Deleted.
+ (JSC::FTL::Output::doublePow): Deleted.
+ (JSC::FTL::Output::doubleSqrt): Deleted.
+ (JSC::FTL::Output::doubleLog): Deleted.
+ (JSC::FTL::Output::signExt32To64): Deleted.
+ (JSC::FTL::Output::zeroExt): Deleted.
+ (JSC::FTL::Output::intToDouble): Deleted.
+ (JSC::FTL::Output::castToInt32): Deleted.
+ (JSC::FTL::Output::doubleToFloat): Deleted.
+ (JSC::FTL::Output::floatToDouble): Deleted.
+ (JSC::FTL::Output::equal): Deleted.
+ (JSC::FTL::Output::notEqual): Deleted.
+ (JSC::FTL::Output::above): Deleted.
+ (JSC::FTL::Output::aboveOrEqual): Deleted.
+ (JSC::FTL::Output::below): Deleted.
+ (JSC::FTL::Output::belowOrEqual): Deleted.
+ (JSC::FTL::Output::greaterThan): Deleted.
+ (JSC::FTL::Output::greaterThanOrEqual): Deleted.
+ (JSC::FTL::Output::lessThan): Deleted.
+ (JSC::FTL::Output::lessThanOrEqual): Deleted.
+ (JSC::FTL::Output::doubleEqual): Deleted.
+ (JSC::FTL::Output::doubleEqualOrUnordered): Deleted.
+ (JSC::FTL::Output::doubleNotEqualOrUnordered): Deleted.
+ (JSC::FTL::Output::doubleLessThan): Deleted.
+ (JSC::FTL::Output::doubleLessThanOrEqual): Deleted.
+ (JSC::FTL::Output::doubleGreaterThan): Deleted.
+ (JSC::FTL::Output::doubleGreaterThanOrEqual): Deleted.
+ (JSC::FTL::Output::doubleNotEqualAndOrdered): Deleted.
+ (JSC::FTL::Output::doubleLessThanOrUnordered): Deleted.
+ (JSC::FTL::Output::doubleLessThanOrEqualOrUnordered): Deleted.
+ (JSC::FTL::Output::doubleGreaterThanOrUnordered): Deleted.
+ (JSC::FTL::Output::doubleGreaterThanOrEqualOrUnordered): Deleted.
+ (JSC::FTL::Output::isZero32): Deleted.
+ (JSC::FTL::Output::notZero32): Deleted.
+ (JSC::FTL::Output::isZero64): Deleted.
+ (JSC::FTL::Output::notZero64): Deleted.
+ (JSC::FTL::Output::select): Deleted.
+ (JSC::FTL::Output::extractValue): Deleted.
+ (JSC::FTL::Output::jump): Deleted.
+ (JSC::FTL::Output::ret): Deleted.
+ (JSC::FTL::Output::unreachable): Deleted.
+ (JSC::FTL::Output::speculate): Deleted.
+ (JSC::FTL::Output::speculateAdd): Deleted.
+ (JSC::FTL::Output::speculateSub): Deleted.
+ (JSC::FTL::Output::speculateMul): Deleted.
+ (JSC::FTL::Output::patchpoint): Deleted.
+ (JSC::FTL::Output::trap): Deleted.
+ (JSC::FTL::Output::anchor): Deleted.
+ (JSC::FTL::Output::bitCast): Deleted.
+ (JSC::FTL::Output::fround): Deleted.
+
</ins><span class="cx"> 2016-06-13 Keith Miller <keith_miller@apple.com>
</span><span class="cx">
</span><span class="cx"> Unreviewed, Cloop build fix.
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLOutputcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLOutput.cpp (202006 => 202007)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLOutput.cpp 2016-06-13 22:00:49 UTC (rev 202006)
+++ trunk/Source/JavaScriptCore/ftl/FTLOutput.cpp 2016-06-13 22:17:50 UTC (rev 202007)
</span><span class="lines">@@ -78,16 +78,136 @@
</span><span class="cx"> m_block = block;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+LValue Output::framePointer()
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::FramePointer, origin());
+}
+
</ins><span class="cx"> SlotBaseValue* Output::lockedStackSlot(size_t bytes)
</span><span class="cx"> {
</span><span class="cx"> return m_block->appendNew<SlotBaseValue>(m_proc, origin(), m_proc.addStackSlot(bytes));
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+LValue Output::constBool(bool value)
+{
+ return m_block->appendNew<B3::Const32Value>(m_proc, origin(), value);
+}
+
+LValue Output::constInt32(int32_t value)
+{
+ return m_block->appendNew<B3::Const32Value>(m_proc, origin(), value);
+}
+
+LValue Output::constInt64(int64_t value)
+{
+ return m_block->appendNew<B3::Const64Value>(m_proc, origin(), value);
+}
+
+LValue Output::constDouble(double value)
+{
+ return m_block->appendNew<B3::ConstDoubleValue>(m_proc, origin(), value);
+}
+
+LValue Output::phi(LType type)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Phi, type, origin());
+}
+
+LValue Output::add(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Add, origin(), left, right);
+}
+
+LValue Output::sub(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Sub, origin(), left, right);
+}
+
+LValue Output::mul(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Mul, origin(), left, right);
+}
+
+LValue Output::div(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Div, origin(), left, right);
+}
+
+LValue Output::chillDiv(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::ChillDiv, origin(), left, right);
+}
+
+LValue Output::mod(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Mod, origin(), left, right);
+}
+
+LValue Output::chillMod(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::ChillMod, origin(), left, right);
+}
+
</ins><span class="cx"> LValue Output::neg(LValue value)
</span><span class="cx"> {
</span><span class="cx"> return m_block->appendNew<Value>(m_proc, B3::Neg, origin(), value);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+LValue Output::doubleAdd(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Add, origin(), left, right);
+}
+
+LValue Output::doubleSub(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Sub, origin(), left, right);
+}
+
+LValue Output::doubleMul(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Mul, origin(), left, right);
+}
+
+LValue Output::doubleDiv(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Div, origin(), left, right);
+}
+
+LValue Output::doubleMod(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Mod, origin(), left, right);
+}
+
+LValue Output::bitAnd(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::BitAnd, origin(), left, right);
+}
+
+LValue Output::bitOr(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::BitOr, origin(), left, right);
+}
+
+LValue Output::bitXor(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::BitXor, origin(), left, right);
+}
+
+LValue Output::shl(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Shl, origin(), left, castToInt32(right));
+}
+
+LValue Output::aShr(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::SShr, origin(), left, castToInt32(right));
+}
+
+LValue Output::lShr(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::ZShr, origin(), left, castToInt32(right));
+}
+
</ins><span class="cx"> LValue Output::bitNot(LValue value)
</span><span class="cx"> {
</span><span class="cx"> return m_block->appendNew<B3::Value>(m_proc, B3::BitXor, origin(),
</span><span class="lines">@@ -100,13 +220,60 @@
</span><span class="cx"> return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), value, int32Zero);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-LValue Output::load(TypedPointer pointer, LType type)
</del><ins>+LValue Output::ctlz32(LValue operand)
</ins><span class="cx"> {
</span><del>- LValue load = m_block->appendNew<MemoryValue>(m_proc, Load, type, origin(), pointer.value());
- m_heaps->decorateMemory(pointer.heap(), load);
- return load;
</del><ins>+ return m_block->appendNew<B3::Value>(m_proc, B3::Clz, origin(), operand);
</ins><span class="cx"> }
</span><span class="cx">
</span><ins>+LValue Output::doubleAbs(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Abs, origin(), value);
+}
+
+LValue Output::doubleCeil(LValue operand)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Ceil, origin(), operand);
+}
+
+LValue Output::doubleFloor(LValue operand)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Floor, origin(), operand);
+}
+
+LValue Output::doubleTrunc(LValue value)
+{
+ if (MacroAssembler::supportsFloatingPointRounding()) {
+ PatchpointValue* result = patchpoint(Double);
+ result->append(value, ValueRep::SomeRegister);
+ result->setGenerator(
+ [] (CCallHelpers& jit, const StackmapGenerationParams& params) {
+ jit.roundTowardZeroDouble(params[1].fpr(), params[0].fpr());
+ });
+ result->effects = Effects::none();
+ return result;
+ }
+ double (*truncDouble)(double) = trunc;
+ return callWithoutSideEffects(Double, truncDouble, value);
+}
+
+LValue Output::doubleSin(LValue value)
+{
+ double (*sinDouble)(double) = sin;
+ return callWithoutSideEffects(B3::Double, sinDouble, value);
+}
+
+LValue Output::doubleCos(LValue value)
+{
+ double (*cosDouble)(double) = cos;
+ return callWithoutSideEffects(B3::Double, cosDouble, value);
+}
+
+LValue Output::doublePow(LValue xOperand, LValue yOperand)
+{
+ double (*powDouble)(double, double) = pow;
+ return callWithoutSideEffects(B3::Double, powDouble, xOperand, yOperand);
+}
+
</ins><span class="cx"> LValue Output::doublePowi(LValue x, LValue y)
</span><span class="cx"> {
</span><span class="cx"> // FIXME: powDoubleInt32() should be inlined here since Output knows about block layout and
</span><span class="lines">@@ -117,6 +284,17 @@
</span><span class="cx"> return result.second;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+LValue Output::doubleSqrt(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Sqrt, origin(), value);
+}
+
+LValue Output::doubleLog(LValue value)
+{
+ double (*logDouble)(double) = log;
+ return callWithoutSideEffects(B3::Double, logDouble, value);
+}
+
</ins><span class="cx"> bool Output::hasSensibleDoubleToInt()
</span><span class="cx"> {
</span><span class="cx"> return optimizeForX86();
</span><span class="lines">@@ -146,27 +324,51 @@
</span><span class="cx"> return result;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-LValue Output::doubleTrunc(LValue value)
</del><ins>+LValue Output::signExt32To64(LValue value)
</ins><span class="cx"> {
</span><del>- if (MacroAssembler::supportsFloatingPointRounding()) {
- PatchpointValue* result = patchpoint(Double);
- result->append(value, ValueRep::SomeRegister);
- result->setGenerator(
- [] (CCallHelpers& jit, const StackmapGenerationParams& params) {
- jit.roundTowardZeroDouble(params[1].fpr(), params[0].fpr());
- });
- result->effects = Effects::none();
- return result;
- }
- double (*truncDouble)(double) = trunc;
- return callWithoutSideEffects(Double, truncDouble, value);
</del><ins>+ return m_block->appendNew<B3::Value>(m_proc, B3::SExt32, origin(), value);
</ins><span class="cx"> }
</span><span class="cx">
</span><ins>+LValue Output::zeroExt(LValue value, LType type)
+{
+ if (value->type() == type)
+ return value;
+ return m_block->appendNew<B3::Value>(m_proc, B3::ZExt32, origin(), value);
+}
+
+LValue Output::intToDouble(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::IToD, origin(), value);
+}
+
</ins><span class="cx"> LValue Output::unsignedToDouble(LValue value)
</span><span class="cx"> {
</span><span class="cx"> return intToDouble(zeroExt(value, Int64));
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+LValue Output::castToInt32(LValue value)
+{
+ return value->type() == B3::Int32 ? value :
+ m_block->appendNew<B3::Value>(m_proc, B3::Trunc, origin(), value);
+}
+
+LValue Output::doubleToFloat(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::DoubleToFloat, origin(), value);
+}
+
+LValue Output::floatToDouble(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::FloatToDouble, origin(), value);
+}
+
+LValue Output::load(TypedPointer pointer, LType type)
+{
+ LValue load = m_block->appendNew<MemoryValue>(m_proc, Load, type, origin(), pointer.value());
+ m_heaps->decorateMemory(pointer.heap(), load);
+ return load;
+}
+
</ins><span class="cx"> LValue Output::load8SignExt32(TypedPointer pointer)
</span><span class="cx"> {
</span><span class="cx"> LValue load = m_block->appendNew<MemoryValue>(m_proc, Load8S, Int32, origin(), pointer.value());
</span><span class="lines">@@ -239,6 +441,146 @@
</span><span class="cx"> return add(base, accumulatedOffset);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+LValue Output::equal(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), left, right);
+}
+
+LValue Output::notEqual(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::NotEqual, origin(), left, right);
+}
+
+LValue Output::above(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Above, origin(), left, right);
+}
+
+LValue Output::aboveOrEqual(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::AboveEqual, origin(), left, right);
+}
+
+LValue Output::below(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Below, origin(), left, right);
+}
+
+LValue Output::belowOrEqual(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::BelowEqual, origin(), left, right);
+}
+
+LValue Output::greaterThan(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::GreaterThan, origin(), left, right);
+}
+
+LValue Output::greaterThanOrEqual(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::GreaterEqual, origin(), left, right);
+}
+
+LValue Output::lessThan(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::LessThan, origin(), left, right);
+}
+
+LValue Output::lessThanOrEqual(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::LessEqual, origin(), left, right);
+}
+
+LValue Output::doubleEqual(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), left, right);
+}
+
+LValue Output::doubleEqualOrUnordered(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::EqualOrUnordered, origin(), left, right);
+}
+
+LValue Output::doubleNotEqualOrUnordered(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::NotEqual, origin(), left, right);
+}
+
+LValue Output::doubleLessThan(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::LessThan, origin(), left, right);
+}
+
+LValue Output::doubleLessThanOrEqual(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::LessEqual, origin(), left, right);
+}
+
+LValue Output::doubleGreaterThan(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::GreaterThan, origin(), left, right);
+}
+
+LValue Output::doubleGreaterThanOrEqual(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::GreaterEqual, origin(), left, right);
+}
+
+LValue Output::doubleNotEqualAndOrdered(LValue left, LValue right)
+{
+ return logicalNot(doubleEqualOrUnordered(left, right));
+}
+
+LValue Output::doubleLessThanOrUnordered(LValue left, LValue right)
+{
+ return logicalNot(doubleGreaterThanOrEqual(left, right));
+}
+
+LValue Output::doubleLessThanOrEqualOrUnordered(LValue left, LValue right)
+{
+ return logicalNot(doubleGreaterThan(left, right));
+}
+
+LValue Output::doubleGreaterThanOrUnordered(LValue left, LValue right)
+{
+ return logicalNot(doubleLessThanOrEqual(left, right));
+}
+
+LValue Output::doubleGreaterThanOrEqualOrUnordered(LValue left, LValue right)
+{
+ return logicalNot(doubleLessThan(left, right));
+}
+
+LValue Output::isZero32(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), value, int32Zero);
+}
+
+LValue Output::notZero32(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::NotEqual, origin(), value, int32Zero);
+}
+
+LValue Output::isZero64(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), value, int64Zero);
+}
+
+LValue Output::notZero64(LValue value)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::NotEqual, origin(), value, int64Zero);
+}
+
+LValue Output::select(LValue value, LValue taken, LValue notTaken)
+{
+ return m_block->appendNew<B3::Value>(m_proc, B3::Select, origin(), value, taken, notTaken);
+}
+
+void Output::jump(LBasicBlock destination)
+{
+ m_block->appendNew<B3::ControlValue>(m_proc, B3::Jump, origin(), B3::FrequentedBlock(destination));
+}
+
</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<ControlValue>(
</span><span class="lines">@@ -259,6 +601,63 @@
</span><span class="cx"> check(condition, taken, taken.weight().inverse());
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+void Output::ret(LValue value)
+{
+ m_block->appendNew<B3::ControlValue>(m_proc, B3::Return, origin(), value);
+}
+
+void Output::unreachable()
+{
+ m_block->appendNew<B3::ControlValue>(m_proc, B3::Oops, origin());
+}
+
+CheckValue* Output::speculate(LValue value)
+{
+ return m_block->appendNew<B3::CheckValue>(m_proc, B3::Check, origin(), value);
+}
+
+CheckValue* Output::speculateAdd(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::CheckValue>(m_proc, B3::CheckAdd, origin(), left, right);
+}
+
+CheckValue* Output::speculateSub(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::CheckValue>(m_proc, B3::CheckSub, origin(), left, right);
+}
+
+CheckValue* Output::speculateMul(LValue left, LValue right)
+{
+ return m_block->appendNew<B3::CheckValue>(m_proc, B3::CheckMul, origin(), left, right);
+}
+
+PatchpointValue* Output::patchpoint(LType type)
+{
+ return m_block->appendNew<B3::PatchpointValue>(m_proc, type, origin());
+}
+
+void Output::trap()
+{
+ m_block->appendNew<B3::ControlValue>(m_proc, B3::Oops, origin());
+}
+
+ValueFromBlock Output::anchor(LValue value)
+{
+ B3::UpsilonValue* upsilon = m_block->appendNew<B3::UpsilonValue>(m_proc, origin(), value);
+ return ValueFromBlock(upsilon, m_block);
+}
+
+LValue Output::bitCast(LValue value, LType type)
+{
+ ASSERT_UNUSED(type, type == int64 || type == doubleType);
+ return m_block->appendNew<B3::Value>(m_proc, B3::BitwiseCast, origin(), value);
+}
+
+LValue Output::fround(LValue doubleValue)
+{
+ return floatToDouble(doubleToFloat(doubleValue));
+}
+
</ins><span class="cx"> LValue Output::load(TypedPointer pointer, LoadType type)
</span><span class="cx"> {
</span><span class="cx"> switch (type) {
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLOutputh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLOutput.h (202006 => 202007)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLOutput.h 2016-06-13 22:00:49 UTC (rev 202006)
+++ trunk/Source/JavaScriptCore/ftl/FTLOutput.h 2016-06-13 22:17:50 UTC (rev 202007)
</span><span class="lines">@@ -99,20 +99,20 @@
</span><span class="cx"> void setOrigin(DFG::Node* node) { m_origin = node; }
</span><span class="cx"> B3::Origin origin() { return B3::Origin(m_origin); }
</span><span class="cx">
</span><del>- LValue framePointer() { return m_block->appendNew<B3::Value>(m_proc, B3::FramePointer, origin()); }
</del><ins>+ LValue framePointer();
</ins><span class="cx">
</span><span class="cx"> B3::SlotBaseValue* lockedStackSlot(size_t bytes);
</span><span class="cx">
</span><del>- LValue constBool(bool value) { return m_block->appendNew<B3::Const32Value>(m_proc, origin(), value); }
- LValue constInt32(int32_t value) { return m_block->appendNew<B3::Const32Value>(m_proc, origin(), value); }
</del><ins>+ LValue constBool(bool value);
+ LValue constInt32(int32_t value);
</ins><span class="cx"> template<typename T>
</span><span class="cx"> LValue constIntPtr(T* value) { return m_block->appendNew<B3::ConstPtrValue>(m_proc, origin(), value); }
</span><span class="cx"> template<typename T>
</span><span class="cx"> LValue constIntPtr(T value) { return m_block->appendNew<B3::ConstPtrValue>(m_proc, origin(), value); }
</span><del>- LValue constInt64(int64_t value) { return m_block->appendNew<B3::Const64Value>(m_proc, origin(), value); }
- LValue constDouble(double value) { return m_block->appendNew<B3::ConstDoubleValue>(m_proc, origin(), value); }
</del><ins>+ LValue constInt64(int64_t value);
+ LValue constDouble(double value);
</ins><span class="cx">
</span><del>- LValue phi(LType type) { return m_block->appendNew<B3::Value>(m_proc, B3::Phi, type, origin()); }
</del><ins>+ LValue phi(LType);
</ins><span class="cx"> template<typename... Params>
</span><span class="cx"> LValue phi(LType, ValueFromBlock, Params... theRest);
</span><span class="cx"> template<typename VectorType>
</span><span class="lines">@@ -121,93 +121,61 @@
</span><span class="cx"> template<typename... Params>
</span><span class="cx"> void addIncomingToPhi(LValue phi, ValueFromBlock, Params... theRest);
</span><span class="cx">
</span><del>- LValue add(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Add, origin(), left, right); }
- LValue sub(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Sub, origin(), left, right); }
- LValue mul(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Mul, origin(), left, right); }
- LValue div(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Div, origin(), left, right); }
- LValue chillDiv(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::ChillDiv, origin(), left, right); }
- LValue mod(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Mod, origin(), left, right); }
- LValue chillMod(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::ChillMod, origin(), left, right); }
</del><ins>+ LValue add(LValue, LValue);
+ LValue sub(LValue, LValue);
+ LValue mul(LValue, LValue);
+ LValue div(LValue, LValue);
+ LValue chillDiv(LValue, LValue);
+ LValue mod(LValue, LValue);
+ LValue chillMod(LValue, LValue);
</ins><span class="cx"> LValue neg(LValue);
</span><span class="cx">
</span><del>- LValue doubleAdd(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Add, origin(), left, right); }
- LValue doubleSub(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Sub, origin(), left, right); }
- LValue doubleMul(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Mul, origin(), left, right); }
- LValue doubleDiv(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Div, origin(), left, right); }
- LValue doubleMod(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Mod, origin(), left, right); }
</del><ins>+ LValue doubleAdd(LValue, LValue);
+ LValue doubleSub(LValue, LValue);
+ LValue doubleMul(LValue, LValue);
+ LValue doubleDiv(LValue, LValue);
+ LValue doubleMod(LValue, LValue);
</ins><span class="cx"> LValue doubleNeg(LValue value) { return neg(value); }
</span><span class="cx">
</span><del>- LValue bitAnd(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::BitAnd, origin(), left, right); }
- LValue bitOr(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::BitOr, origin(), left, right); }
- LValue bitXor(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::BitXor, origin(), left, right); }
- 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)); }
</del><ins>+ LValue bitAnd(LValue, LValue);
+ LValue bitOr(LValue, LValue);
+ LValue bitXor(LValue, LValue);
+ LValue shl(LValue, LValue shiftAmount);
+ LValue aShr(LValue, LValue shiftAmount);
+ LValue lShr(LValue, LValue shiftAmount);
</ins><span class="cx"> LValue bitNot(LValue);
</span><span class="cx"> LValue logicalNot(LValue);
</span><span class="cx">
</span><del>- LValue ctlz32(LValue operand) { return m_block->appendNew<B3::Value>(m_proc, B3::Clz, origin(), operand); }
- LValue addWithOverflow32(LValue left, LValue right) { CRASH(); }
- LValue subWithOverflow32(LValue left, LValue right) { CRASH(); }
- LValue mulWithOverflow32(LValue left, LValue right) { CRASH(); }
- LValue addWithOverflow64(LValue left, LValue right) { CRASH(); }
- LValue subWithOverflow64(LValue left, LValue right) { CRASH(); }
- LValue mulWithOverflow64(LValue left, LValue right) { CRASH(); }
- LValue doubleAbs(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::Abs, origin(), value); }
- LValue doubleCeil(LValue operand) { return m_block->appendNew<B3::Value>(m_proc, B3::Ceil, origin(), operand); }
- LValue doubleFloor(LValue operand) { return m_block->appendNew<B3::Value>(m_proc, B3::Floor, origin(), operand); }
</del><ins>+ LValue ctlz32(LValue);
+ LValue doubleAbs(LValue);
+ LValue doubleCeil(LValue);
+ LValue doubleFloor(LValue);
</ins><span class="cx"> LValue doubleTrunc(LValue);
</span><span class="cx">
</span><del>- LValue doubleSin(LValue value)
- {
- double (*sinDouble)(double) = sin;
- return callWithoutSideEffects(B3::Double, sinDouble, value);
- }
- LValue doubleCos(LValue value)
- {
- double (*cosDouble)(double) = cos;
- return callWithoutSideEffects(B3::Double, cosDouble, value);
- }
</del><ins>+ LValue doubleSin(LValue);
+ LValue doubleCos(LValue);
</ins><span class="cx">
</span><del>- LValue doublePow(LValue xOperand, LValue yOperand)
- {
- double (*powDouble)(double, double) = pow;
- return callWithoutSideEffects(B3::Double, powDouble, xOperand, yOperand);
- }
</del><ins>+ LValue doublePow(LValue base, LValue exponent);
+ LValue doublePowi(LValue base, LValue exponent);
</ins><span class="cx">
</span><del>- LValue doublePowi(LValue xOperand, LValue yOperand);
</del><ins>+ LValue doubleSqrt(LValue);
</ins><span class="cx">
</span><del>- LValue doubleSqrt(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::Sqrt, origin(), value); }
</del><ins>+ LValue doubleLog(LValue);
</ins><span class="cx">
</span><del>- LValue doubleLog(LValue value)
- {
- double (*logDouble)(double) = log;
- return callWithoutSideEffects(B3::Double, logDouble, value);
- }
-
</del><span class="cx"> static bool hasSensibleDoubleToInt();
</span><span class="cx"> LValue doubleToInt(LValue);
</span><span class="cx"> LValue doubleToUInt(LValue);
</span><span class="cx">
</span><del>- LValue signExt32To64(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::SExt32, origin(), value); }
- LValue zeroExt(LValue value, LType type)
- {
- if (value->type() == type)
- return value;
- return m_block->appendNew<B3::Value>(m_proc, B3::ZExt32, origin(), value);
- }
</del><ins>+ LValue signExt32To64(LValue);
+ LValue zeroExt(LValue, LType);
</ins><span class="cx"> LValue zeroExtPtr(LValue value) { return zeroExt(value, B3::Int64); }
</span><del>- LValue intToDouble(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::IToD, origin(), value); }
</del><ins>+ LValue intToDouble(LValue);
</ins><span class="cx"> LValue unsignedToDouble(LValue);
</span><del>- LValue castToInt32(LValue value)
- {
- return value->type() == B3::Int32 ? value :
- m_block->appendNew<B3::Value>(m_proc, B3::Trunc, origin(), value);
- }
- LValue doubleToFloat(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::DoubleToFloat, origin(), value); }
- LValue floatToDouble(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::FloatToDouble, origin(), value); }
</del><ins>+ LValue castToInt32(LValue);
+ LValue doubleToFloat(LValue);
+ LValue floatToDouble(LValue);
</ins><span class="cx"> LValue bitCast(LValue, LType);
</span><del>- LValue fround(LValue doubleValue);
</del><ins>+ LValue fround(LValue);
</ins><span class="cx">
</span><span class="cx"> LValue load(TypedPointer, LType);
</span><span class="cx"> void store(LValue, TypedPointer);
</span><span class="lines">@@ -221,8 +189,8 @@
</span><span class="cx"> LValue loadPtr(TypedPointer pointer) { return load(pointer, B3::pointerType()); }
</span><span class="cx"> LValue loadFloat(TypedPointer pointer) { return load(pointer, B3::Float); }
</span><span class="cx"> LValue loadDouble(TypedPointer pointer) { return load(pointer, B3::Double); }
</span><del>- void store32As8(LValue value, TypedPointer pointer);
- void store32As16(LValue value, TypedPointer pointer);
</del><ins>+ void store32As8(LValue, TypedPointer);
+ void store32As16(LValue, TypedPointer);
</ins><span class="cx"> void store32(LValue value, TypedPointer pointer)
</span><span class="cx"> {
</span><span class="cx"> ASSERT(value->type() == B3::Int32);
</span><span class="lines">@@ -330,34 +298,34 @@
</span><span class="cx"> LValue load32NonNegative(TypedPointer pointer) { return load32(pointer); }
</span><span class="cx"> LValue load32NonNegative(LValue base, const AbstractHeap& field) { return load32(base, field); }
</span><span class="cx">
</span><del>- LValue equal(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), left, right); }
- LValue notEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::NotEqual, origin(), left, right); }
- LValue above(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Above, origin(), left, right); }
- LValue aboveOrEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::AboveEqual, origin(), left, right); }
- LValue below(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Below, origin(), left, right); }
- LValue belowOrEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::BelowEqual, origin(), left, right); }
- LValue greaterThan(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::GreaterThan, origin(), left, right); }
- LValue greaterThanOrEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::GreaterEqual, origin(), left, right); }
- LValue lessThan(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::LessThan, origin(), left, right); }
- LValue lessThanOrEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::LessEqual, origin(), left, right); }
</del><ins>+ LValue equal(LValue, LValue);
+ LValue notEqual(LValue, LValue);
+ LValue above(LValue, LValue);
+ LValue aboveOrEqual(LValue, LValue);
+ LValue below(LValue, LValue);
+ LValue belowOrEqual(LValue, LValue);
+ LValue greaterThan(LValue, LValue);
+ LValue greaterThanOrEqual(LValue, LValue);
+ LValue lessThan(LValue, LValue);
+ LValue lessThanOrEqual(LValue, LValue);
</ins><span class="cx">
</span><del>- LValue doubleEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), left, right); }
- LValue doubleEqualOrUnordered(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::EqualOrUnordered, origin(), left, right); }
- LValue doubleNotEqualOrUnordered(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::NotEqual, origin(), left, right); }
- LValue doubleLessThan(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::LessThan, origin(), left, right); }
- LValue doubleLessThanOrEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::LessEqual, origin(), left, right); }
- LValue doubleGreaterThan(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::GreaterThan, origin(), left, right); }
- LValue doubleGreaterThanOrEqual(LValue left, LValue right) { return m_block->appendNew<B3::Value>(m_proc, B3::GreaterEqual, origin(), left, right); }
- LValue doubleNotEqualAndOrdered(LValue left, LValue right) { return logicalNot(doubleEqualOrUnordered(left, right)); }
- LValue doubleLessThanOrUnordered(LValue left, LValue right) { return logicalNot(doubleGreaterThanOrEqual(left, right)); }
- LValue doubleLessThanOrEqualOrUnordered(LValue left, LValue right) { return logicalNot(doubleGreaterThan(left, right)); }
- LValue doubleGreaterThanOrUnordered(LValue left, LValue right) { return logicalNot(doubleLessThanOrEqual(left, right)); }
- LValue doubleGreaterThanOrEqualOrUnordered(LValue left, LValue right) { return logicalNot(doubleLessThan(left, right)); }
</del><ins>+ LValue doubleEqual(LValue, LValue);
+ LValue doubleEqualOrUnordered(LValue, LValue);
+ LValue doubleNotEqualOrUnordered(LValue, LValue);
+ LValue doubleLessThan(LValue, LValue);
+ LValue doubleLessThanOrEqual(LValue, LValue);
+ LValue doubleGreaterThan(LValue, LValue);
+ LValue doubleGreaterThanOrEqual(LValue, LValue);
+ LValue doubleNotEqualAndOrdered(LValue, LValue);
+ LValue doubleLessThanOrUnordered(LValue, LValue);
+ LValue doubleLessThanOrEqualOrUnordered(LValue, LValue);
+ LValue doubleGreaterThanOrUnordered(LValue, LValue);
+ LValue doubleGreaterThanOrEqualOrUnordered(LValue, LValue);
</ins><span class="cx">
</span><del>- LValue isZero32(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), value, int32Zero); }
- LValue notZero32(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::NotEqual, origin(), value, int32Zero); }
- LValue isZero64(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::Equal, origin(), value, int64Zero); }
- LValue notZero64(LValue value) { return m_block->appendNew<B3::Value>(m_proc, B3::NotEqual, origin(), value, int64Zero); }
</del><ins>+ LValue isZero32(LValue);
+ LValue notZero32(LValue);
+ LValue isZero64(LValue);
+ LValue notZero64(LValue);
</ins><span class="cx"> LValue isNull(LValue value) { return isZero64(value); }
</span><span class="cx"> LValue notNull(LValue value) { return notZero64(value); }
</span><span class="cx">
</span><span class="lines">@@ -368,8 +336,7 @@
</span><span class="cx"> LValue testIsZeroPtr(LValue value, LValue mask) { return isNull(bitAnd(value, mask)); }
</span><span class="cx"> LValue testNonZeroPtr(LValue value, LValue mask) { return notNull(bitAnd(value, mask)); }
</span><span class="cx">
</span><del>- LValue select(LValue value, LValue taken, LValue notTaken) { return m_block->appendNew<B3::Value>(m_proc, B3::Select, origin(), value, taken, notTaken); }
- LValue extractValue(LValue aggVal, unsigned index) { CRASH(); }
</del><ins>+ LValue select(LValue value, LValue taken, LValue notTaken);
</ins><span class="cx">
</span><span class="cx"> template<typename VectorType>
</span><span class="cx"> LValue call(LType type, LValue function, const VectorType& vector)
</span><span class="lines">@@ -394,7 +361,7 @@
</span><span class="cx"> template<typename FunctionType>
</span><span class="cx"> LValue operation(FunctionType function) { return constIntPtr(bitwise_cast<void*>(function)); }
</span><span class="cx">
</span><del>- void jump(LBasicBlock destination) { m_block->appendNew<B3::ControlValue>(m_proc, B3::Jump, origin(), B3::FrequentedBlock(destination)); }
</del><ins>+ void jump(LBasicBlock);
</ins><span class="cx"> void branch(LValue condition, LBasicBlock taken, Weight takenWeight, LBasicBlock notTaken, Weight notTakenWeight);
</span><span class="cx"> void branch(LValue condition, WeightedTarget taken, WeightedTarget notTaken)
</span><span class="cx"> {
</span><span class="lines">@@ -420,46 +387,21 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void ret(LValue value) { m_block->appendNew<B3::ControlValue>(m_proc, B3::Return, origin(), value); }
</del><ins>+ void ret(LValue);
</ins><span class="cx">
</span><del>- void unreachable() { m_block->appendNew<B3::ControlValue>(m_proc, B3::Oops, origin()); }
</del><ins>+ void unreachable();
</ins><span class="cx">
</span><del>- B3::CheckValue* speculate(LValue value)
- {
- return m_block->appendNew<B3::CheckValue>(m_proc, B3::Check, origin(), value);
- }
</del><ins>+ B3::CheckValue* speculate(LValue);
+ B3::CheckValue* speculateAdd(LValue, LValue);
+ B3::CheckValue* speculateSub(LValue, LValue);
+ B3::CheckValue* speculateMul(LValue, LValue);
</ins><span class="cx">
</span><del>- B3::CheckValue* speculateAdd(LValue left, LValue right)
- {
- return m_block->appendNew<B3::CheckValue>(m_proc, B3::CheckAdd, origin(), left, right);
- }
</del><ins>+ B3::PatchpointValue* patchpoint(LType);
</ins><span class="cx">
</span><del>- B3::CheckValue* speculateSub(LValue left, LValue right)
- {
- return m_block->appendNew<B3::CheckValue>(m_proc, B3::CheckSub, origin(), left, right);
- }
</del><ins>+ void trap();
</ins><span class="cx">
</span><del>- B3::CheckValue* speculateMul(LValue left, LValue right)
- {
- return m_block->appendNew<B3::CheckValue>(m_proc, B3::CheckMul, origin(), left, right);
- }
</del><ins>+ ValueFromBlock anchor(LValue);
</ins><span class="cx">
</span><del>- B3::PatchpointValue* patchpoint(LType type)
- {
- return m_block->appendNew<B3::PatchpointValue>(m_proc, type, origin());
- }
-
- void trap()
- {
- m_block->appendNew<B3::ControlValue>(m_proc, B3::Oops, origin());
- }
-
- ValueFromBlock anchor(LValue value)
- {
- B3::UpsilonValue* upsilon = m_block->appendNew<B3::UpsilonValue>(m_proc, origin(), value);
- return ValueFromBlock(upsilon, m_block);
- }
-
</del><span class="cx"> void incrementSuperSamplerCount();
</span><span class="cx"> void decrementSuperSamplerCount();
</span><span class="cx">
</span><span class="lines">@@ -509,17 +451,6 @@
</span><span class="cx"> addIncomingToPhi(phi, theRest...);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline LValue Output::bitCast(LValue value, LType type)
-{
- ASSERT_UNUSED(type, type == int64 || type == doubleType);
- return m_block->appendNew<B3::Value>(m_proc, B3::BitwiseCast, origin(), value);
-}
-
-inline LValue Output::fround(LValue doubleValue)
-{
- return floatToDouble(doubleToFloat(doubleValue));
-}
-
</del><span class="cx"> #if COMPILER(GCC_OR_CLANG)
</span><span class="cx"> #pragma GCC diagnostic pop
</span><span class="cx"> #endif // COMPILER(GCC_OR_CLANG)
</span></span></pre>
</div>
</div>
</body>
</html>