<!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>[164389] 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/164389">164389</a></dd>
<dt>Author</dt> <dd>fpizlo@apple.com</dd>
<dt>Date</dt> <dd>2014-02-19 14:29:43 -0800 (Wed, 19 Feb 2014)</dd>
</dl>
<h3>Log Message</h3>
<pre>FTL should be able to convey branch weights to LLVM
https://bugs.webkit.org/show_bug.cgi?id=129054
Reviewed by Michael Saboff.
This introduces a really nice way to convey branch weights to LLVM. The basic class
is Weight, which just wraps a float; NaN is used when you are not sure. You can
pass this alongside a LBasicBlock to branching instructions like condbr and switch.
But for simplicity, you can just pass a WeightedTarget, which is a tuple of the
two. And for even greater simplicity, you can create WeightedTargets from
LBasicBlocks by doing:
usually(b) => WeightedTarget(b, Weight(1))
rarely(b) => WeightedTarget(b, Weight(0))
unsure(b) => WeightedTarget(b, Weight()) or WeightedTarget(b, Weight(NaN))
This allows for constructs like:
m_out.branch(isCell(value), usually(isCellCase), rarely(slowCase));
This was intended to be perf-neutral for now, but it did end up creating a ~1%
speed-up on V8v7 and Octane2.
* JavaScriptCore.xcodeproj/project.pbxproj:
* ftl/FTLAbbreviations.h:
(JSC::FTL::mdNode):
* ftl/FTLCommonValues.cpp:
(JSC::FTL::CommonValues::CommonValues):
* ftl/FTLCommonValues.h:
* ftl/FTLLowerDFGToLLVM.cpp:
(JSC::FTL::LowerDFGToLLVM::lower):
(JSC::FTL::LowerDFGToLLVM::compileValueToInt32):
(JSC::FTL::LowerDFGToLLVM::compileStoreBarrierWithNullCheck):
(JSC::FTL::LowerDFGToLLVM::compileToThis):
(JSC::FTL::LowerDFGToLLVM::compileArithMul):
(JSC::FTL::LowerDFGToLLVM::compileArithDiv):
(JSC::FTL::LowerDFGToLLVM::compileArithMod):
(JSC::FTL::LowerDFGToLLVM::compileArithMinOrMax):
(JSC::FTL::LowerDFGToLLVM::compileCheckStructure):
(JSC::FTL::LowerDFGToLLVM::compileArrayifyToStructure):
(JSC::FTL::LowerDFGToLLVM::compileGetById):
(JSC::FTL::LowerDFGToLLVM::compileGetIndexedPropertyStorage):
(JSC::FTL::LowerDFGToLLVM::compileGetTypedArrayByteOffset):
(JSC::FTL::LowerDFGToLLVM::compileGetByVal):
(JSC::FTL::LowerDFGToLLVM::compilePutByVal):
(JSC::FTL::LowerDFGToLLVM::compileArrayPush):
(JSC::FTL::LowerDFGToLLVM::compileArrayPop):
(JSC::FTL::LowerDFGToLLVM::compileNewArrayWithSize):
(JSC::FTL::LowerDFGToLLVM::compileToString):
(JSC::FTL::LowerDFGToLLVM::compileToPrimitive):
(JSC::FTL::LowerDFGToLLVM::compileStringCharAt):
(JSC::FTL::LowerDFGToLLVM::compileStringCharCodeAt):
(JSC::FTL::LowerDFGToLLVM::compileMultiGetByOffset):
(JSC::FTL::LowerDFGToLLVM::compileNotifyWrite):
(JSC::FTL::LowerDFGToLLVM::compileBranch):
(JSC::FTL::LowerDFGToLLVM::compileSwitch):
(JSC::FTL::LowerDFGToLLVM::compareEqObjectOrOtherToObject):
(JSC::FTL::LowerDFGToLLVM::nonSpeculativeCompare):
(JSC::FTL::LowerDFGToLLVM::allocateCell):
(JSC::FTL::LowerDFGToLLVM::allocateBasicStorageAndGetEnd):
(JSC::FTL::LowerDFGToLLVM::boolify):
(JSC::FTL::LowerDFGToLLVM::equalNullOrUndefined):
(JSC::FTL::LowerDFGToLLVM::contiguousPutByValOutOfBounds):
(JSC::FTL::LowerDFGToLLVM::buildSwitch):
(JSC::FTL::LowerDFGToLLVM::doubleToInt32):
(JSC::FTL::LowerDFGToLLVM::sensibleDoubleToInt32):
(JSC::FTL::LowerDFGToLLVM::lowDouble):
(JSC::FTL::LowerDFGToLLVM::strictInt52ToJSValue):
(JSC::FTL::LowerDFGToLLVM::speculateObjectOrOther):
(JSC::FTL::LowerDFGToLLVM::speculateStringOrStringObject):
(JSC::FTL::LowerDFGToLLVM::emitStoreBarrier):
(JSC::FTL::LowerDFGToLLVM::callCheck):
(JSC::FTL::LowerDFGToLLVM::appendOSRExit):
* ftl/FTLOutput.cpp:
(JSC::FTL::Output::initialize):
(JSC::FTL::Output::appendTo):
(JSC::FTL::Output::newBlock):
(JSC::FTL::Output::sensibleDoubleToInt):
(JSC::FTL::Output::load):
(JSC::FTL::Output::store):
(JSC::FTL::Output::baseIndex):
(JSC::FTL::Output::branch):
(JSC::FTL::Output::crashNonTerminal):
* ftl/FTLOutput.h:
(JSC::FTL::Output::branch):
(JSC::FTL::Output::switchInstruction):
* ftl/FTLSwitchCase.h:
(JSC::FTL::SwitchCase::SwitchCase):
(JSC::FTL::SwitchCase::weight):
* ftl/FTLWeight.h: Added.
(JSC::FTL::Weight::Weight):
(JSC::FTL::Weight::isSet):
(JSC::FTL::Weight::operator!):
(JSC::FTL::Weight::value):
(JSC::FTL::Weight::scaleToTotal):
* ftl/FTLWeightedTarget.h: Added.
(JSC::FTL::WeightedTarget::WeightedTarget):
(JSC::FTL::WeightedTarget::target):
(JSC::FTL::WeightedTarget::weight):
(JSC::FTL::usually):
(JSC::FTL::rarely):
(JSC::FTL::unsure):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCoreJavaScriptCorexcodeprojprojectpbxproj">trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLAbbreviationsh">trunk/Source/JavaScriptCore/ftl/FTLAbbreviations.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLCommonValuescpp">trunk/Source/JavaScriptCore/ftl/FTLCommonValues.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLCommonValuesh">trunk/Source/JavaScriptCore/ftl/FTLCommonValues.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLLowerDFGToLLVMcpp">trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp</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>
<li><a href="#trunkSourceJavaScriptCoreftlFTLSwitchCaseh">trunk/Source/JavaScriptCore/ftl/FTLSwitchCase.h</a></li>
</ul>
<h3>Added Paths</h3>
<ul>
<li><a href="#trunkSourceJavaScriptCoreftlFTLWeighth">trunk/Source/JavaScriptCore/ftl/FTLWeight.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLWeightedTargeth">trunk/Source/JavaScriptCore/ftl/FTLWeightedTarget.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (164388 => 164389)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2014-02-19 21:57:41 UTC (rev 164388)
+++ trunk/Source/JavaScriptCore/ChangeLog 2014-02-19 22:29:43 UTC (rev 164389)
</span><span class="lines">@@ -1,3 +1,108 @@
</span><ins>+2014-02-19 Filip Pizlo <fpizlo@apple.com>
+
+ FTL should be able to convey branch weights to LLVM
+ https://bugs.webkit.org/show_bug.cgi?id=129054
+
+ Reviewed by Michael Saboff.
+
+ This introduces a really nice way to convey branch weights to LLVM. The basic class
+ is Weight, which just wraps a float; NaN is used when you are not sure. You can
+ pass this alongside a LBasicBlock to branching instructions like condbr and switch.
+ But for simplicity, you can just pass a WeightedTarget, which is a tuple of the
+ two. And for even greater simplicity, you can create WeightedTargets from
+ LBasicBlocks by doing:
+
+ usually(b) => WeightedTarget(b, Weight(1))
+ rarely(b) => WeightedTarget(b, Weight(0))
+ unsure(b) => WeightedTarget(b, Weight()) or WeightedTarget(b, Weight(NaN))
+
+ This allows for constructs like:
+
+ m_out.branch(isCell(value), usually(isCellCase), rarely(slowCase));
+
+ This was intended to be perf-neutral for now, but it did end up creating a ~1%
+ speed-up on V8v7 and Octane2.
+
+ * JavaScriptCore.xcodeproj/project.pbxproj:
+ * ftl/FTLAbbreviations.h:
+ (JSC::FTL::mdNode):
+ * ftl/FTLCommonValues.cpp:
+ (JSC::FTL::CommonValues::CommonValues):
+ * ftl/FTLCommonValues.h:
+ * ftl/FTLLowerDFGToLLVM.cpp:
+ (JSC::FTL::LowerDFGToLLVM::lower):
+ (JSC::FTL::LowerDFGToLLVM::compileValueToInt32):
+ (JSC::FTL::LowerDFGToLLVM::compileStoreBarrierWithNullCheck):
+ (JSC::FTL::LowerDFGToLLVM::compileToThis):
+ (JSC::FTL::LowerDFGToLLVM::compileArithMul):
+ (JSC::FTL::LowerDFGToLLVM::compileArithDiv):
+ (JSC::FTL::LowerDFGToLLVM::compileArithMod):
+ (JSC::FTL::LowerDFGToLLVM::compileArithMinOrMax):
+ (JSC::FTL::LowerDFGToLLVM::compileCheckStructure):
+ (JSC::FTL::LowerDFGToLLVM::compileArrayifyToStructure):
+ (JSC::FTL::LowerDFGToLLVM::compileGetById):
+ (JSC::FTL::LowerDFGToLLVM::compileGetIndexedPropertyStorage):
+ (JSC::FTL::LowerDFGToLLVM::compileGetTypedArrayByteOffset):
+ (JSC::FTL::LowerDFGToLLVM::compileGetByVal):
+ (JSC::FTL::LowerDFGToLLVM::compilePutByVal):
+ (JSC::FTL::LowerDFGToLLVM::compileArrayPush):
+ (JSC::FTL::LowerDFGToLLVM::compileArrayPop):
+ (JSC::FTL::LowerDFGToLLVM::compileNewArrayWithSize):
+ (JSC::FTL::LowerDFGToLLVM::compileToString):
+ (JSC::FTL::LowerDFGToLLVM::compileToPrimitive):
+ (JSC::FTL::LowerDFGToLLVM::compileStringCharAt):
+ (JSC::FTL::LowerDFGToLLVM::compileStringCharCodeAt):
+ (JSC::FTL::LowerDFGToLLVM::compileMultiGetByOffset):
+ (JSC::FTL::LowerDFGToLLVM::compileNotifyWrite):
+ (JSC::FTL::LowerDFGToLLVM::compileBranch):
+ (JSC::FTL::LowerDFGToLLVM::compileSwitch):
+ (JSC::FTL::LowerDFGToLLVM::compareEqObjectOrOtherToObject):
+ (JSC::FTL::LowerDFGToLLVM::nonSpeculativeCompare):
+ (JSC::FTL::LowerDFGToLLVM::allocateCell):
+ (JSC::FTL::LowerDFGToLLVM::allocateBasicStorageAndGetEnd):
+ (JSC::FTL::LowerDFGToLLVM::boolify):
+ (JSC::FTL::LowerDFGToLLVM::equalNullOrUndefined):
+ (JSC::FTL::LowerDFGToLLVM::contiguousPutByValOutOfBounds):
+ (JSC::FTL::LowerDFGToLLVM::buildSwitch):
+ (JSC::FTL::LowerDFGToLLVM::doubleToInt32):
+ (JSC::FTL::LowerDFGToLLVM::sensibleDoubleToInt32):
+ (JSC::FTL::LowerDFGToLLVM::lowDouble):
+ (JSC::FTL::LowerDFGToLLVM::strictInt52ToJSValue):
+ (JSC::FTL::LowerDFGToLLVM::speculateObjectOrOther):
+ (JSC::FTL::LowerDFGToLLVM::speculateStringOrStringObject):
+ (JSC::FTL::LowerDFGToLLVM::emitStoreBarrier):
+ (JSC::FTL::LowerDFGToLLVM::callCheck):
+ (JSC::FTL::LowerDFGToLLVM::appendOSRExit):
+ * ftl/FTLOutput.cpp:
+ (JSC::FTL::Output::initialize):
+ (JSC::FTL::Output::appendTo):
+ (JSC::FTL::Output::newBlock):
+ (JSC::FTL::Output::sensibleDoubleToInt):
+ (JSC::FTL::Output::load):
+ (JSC::FTL::Output::store):
+ (JSC::FTL::Output::baseIndex):
+ (JSC::FTL::Output::branch):
+ (JSC::FTL::Output::crashNonTerminal):
+ * ftl/FTLOutput.h:
+ (JSC::FTL::Output::branch):
+ (JSC::FTL::Output::switchInstruction):
+ * ftl/FTLSwitchCase.h:
+ (JSC::FTL::SwitchCase::SwitchCase):
+ (JSC::FTL::SwitchCase::weight):
+ * ftl/FTLWeight.h: Added.
+ (JSC::FTL::Weight::Weight):
+ (JSC::FTL::Weight::isSet):
+ (JSC::FTL::Weight::operator!):
+ (JSC::FTL::Weight::value):
+ (JSC::FTL::Weight::scaleToTotal):
+ * ftl/FTLWeightedTarget.h: Added.
+ (JSC::FTL::WeightedTarget::WeightedTarget):
+ (JSC::FTL::WeightedTarget::target):
+ (JSC::FTL::WeightedTarget::weight):
+ (JSC::FTL::usually):
+ (JSC::FTL::rarely):
+ (JSC::FTL::unsure):
+
</ins><span class="cx"> 2014-02-19 peavo@outlook.com <peavo@outlook.com>
</span><span class="cx">
</span><span class="cx"> [Win][LLINT] Incorrect stack alignment.
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreJavaScriptCorexcodeprojprojectpbxproj"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj (164388 => 164389)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj 2014-02-19 21:57:41 UTC (rev 164388)
+++ trunk/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj 2014-02-19 22:29:43 UTC (rev 164389)
</span><span class="lines">@@ -62,6 +62,8 @@
</span><span class="cx"> 0F0332C018ADFAE1005F979A /* ExitingJITType.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F0332BF18ADFAE1005F979A /* ExitingJITType.cpp */; };
</span><span class="cx"> 0F0332C318B01763005F979A /* GetByIdVariant.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F0332C118B01763005F979A /* GetByIdVariant.cpp */; };
</span><span class="cx"> 0F0332C418B01763005F979A /* GetByIdVariant.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F0332C218B01763005F979A /* GetByIdVariant.h */; settings = {ATTRIBUTES = (Private, ); }; };
</span><ins>+ 0F0332C618B53FA9005F979A /* FTLWeight.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F0332C518B53FA9005F979A /* FTLWeight.h */; settings = {ATTRIBUTES = (Private, ); }; };
+ 0F0332C818B546EC005F979A /* FTLWeightedTarget.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F0332C718B546EC005F979A /* FTLWeightedTarget.h */; settings = {ATTRIBUTES = (Private, ); }; };
</ins><span class="cx"> 0F05C3B41683CF9200BAF45B /* DFGArrayifySlowPathGenerator.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F05C3B21683CF8F00BAF45B /* DFGArrayifySlowPathGenerator.h */; settings = {ATTRIBUTES = (Private, ); }; };
</span><span class="cx"> 0F0776BF14FF002B00102332 /* JITCompilationEffort.h in Headers */ = {isa = PBXBuildFile; fileRef = 0F0776BD14FF002800102332 /* JITCompilationEffort.h */; settings = {ATTRIBUTES = (Private, ); }; };
</span><span class="cx"> 0F0B839C14BCF46300885B4F /* LLIntThunks.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0F0B839714BCF45A00885B4F /* LLIntThunks.cpp */; };
</span><span class="lines">@@ -1532,6 +1534,8 @@
</span><span class="cx"> 0F0332BF18ADFAE1005F979A /* ExitingJITType.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ExitingJITType.cpp; sourceTree = "<group>"; };
</span><span class="cx"> 0F0332C118B01763005F979A /* GetByIdVariant.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = GetByIdVariant.cpp; sourceTree = "<group>"; };
</span><span class="cx"> 0F0332C218B01763005F979A /* GetByIdVariant.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = GetByIdVariant.h; sourceTree = "<group>"; };
</span><ins>+ 0F0332C518B53FA9005F979A /* FTLWeight.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FTLWeight.h; path = ftl/FTLWeight.h; sourceTree = "<group>"; };
+ 0F0332C718B546EC005F979A /* FTLWeightedTarget.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = FTLWeightedTarget.h; path = ftl/FTLWeightedTarget.h; sourceTree = "<group>"; };
</ins><span class="cx"> 0F05C3B21683CF8F00BAF45B /* DFGArrayifySlowPathGenerator.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = DFGArrayifySlowPathGenerator.h; path = dfg/DFGArrayifySlowPathGenerator.h; sourceTree = "<group>"; };
</span><span class="cx"> 0F0776BD14FF002800102332 /* JITCompilationEffort.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JITCompilationEffort.h; sourceTree = "<group>"; };
</span><span class="cx"> 0F0B839714BCF45A00885B4F /* LLIntThunks.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = LLIntThunks.cpp; path = llint/LLIntThunks.cpp; sourceTree = "<group>"; };
</span><span class="lines">@@ -3155,8 +3159,6 @@
</span><span class="cx"> 0FEA09FC1705137F00BB722C /* ftl */ = {
</span><span class="cx"> isa = PBXGroup;
</span><span class="cx"> children = (
</span><del>- 2AC922B918A16182003CE0FB /* FTLDWARFDebugLineInfo.cpp */,
- 2AC922BA18A16182003CE0FB /* FTLDWARFDebugLineInfo.h */,
</del><span class="cx"> 0FDB2CC7173DA51E007B3C1B /* FTLAbbreviatedTypes.h */,
</span><span class="cx"> 0FEA09FD170513DB00BB722C /* FTLAbbreviations.h */,
</span><span class="cx"> 0FEA0A171708B00700BB722C /* FTLAbstractHeap.cpp */,
</span><span class="lines">@@ -3171,6 +3173,8 @@
</span><span class="cx"> 0FEA0A211709606900BB722C /* FTLCommonValues.h */,
</span><span class="cx"> 0FEA0A00170513DB00BB722C /* FTLCompile.cpp */,
</span><span class="cx"> 0FEA0A01170513DB00BB722C /* FTLCompile.h */,
</span><ins>+ 2AC922B918A16182003CE0FB /* FTLDWARFDebugLineInfo.cpp */,
+ 2AC922BA18A16182003CE0FB /* FTLDWARFDebugLineInfo.h */,
</ins><span class="cx"> 0F235BBD17178E1C00690C7F /* FTLExitArgument.cpp */,
</span><span class="cx"> 0F235BBE17178E1C00690C7F /* FTLExitArgument.h */,
</span><span class="cx"> 0F235BBF17178E1C00690C7F /* FTLExitArgumentForOperand.cpp */,
</span><span class="lines">@@ -3238,6 +3242,8 @@
</span><span class="cx"> 0FDB2CC8173DA51E007B3C1B /* FTLValueFromBlock.h */,
</span><span class="cx"> 0F5A6281188C98D40072C9DF /* FTLValueRange.cpp */,
</span><span class="cx"> 0F5A6282188C98D40072C9DF /* FTLValueRange.h */,
</span><ins>+ 0F0332C518B53FA9005F979A /* FTLWeight.h */,
+ 0F0332C718B546EC005F979A /* FTLWeightedTarget.h */,
</ins><span class="cx"> );
</span><span class="cx"> name = ftl;
</span><span class="cx"> sourceTree = "<group>";
</span><span class="lines">@@ -5039,6 +5045,7 @@
</span><span class="cx"> A7D89D0017A0B8CC00773AD8 /* DFGSSAConversionPhase.h in Headers */,
</span><span class="cx"> 0F9FB4F517FCB91700CB67F8 /* DFGStackLayoutPhase.h in Headers */,
</span><span class="cx"> A593CF831840377100BFCE27 /* InspectorValues.h in Headers */,
</span><ins>+ 0F0332C818B546EC005F979A /* FTLWeightedTarget.h in Headers */,
</ins><span class="cx"> 0F63947815DCE34B006A597C /* DFGStructureAbstractValue.h in Headers */,
</span><span class="cx"> 0FC097A2146B28CC00CF2442 /* DFGThunks.h in Headers */,
</span><span class="cx"> 0FD8A32817D51F5700CA2C40 /* DFGTierUpCheckInjectionPhase.h in Headers */,
</span><span class="lines">@@ -5540,6 +5547,7 @@
</span><span class="cx"> A7A8AF4217ADB5F3005AB174 /* Uint32Array.h in Headers */,
</span><span class="cx"> A5FD0086189B1B7E00633231 /* JSGlobalObjectConsoleAgent.h in Headers */,
</span><span class="cx"> A7A8AF3F17ADB5F3005AB174 /* Uint8Array.h in Headers */,
</span><ins>+ 0F0332C618B53FA9005F979A /* FTLWeight.h in Headers */,
</ins><span class="cx"> A7A8AF4017ADB5F3005AB174 /* Uint8ClampedArray.h in Headers */,
</span><span class="cx"> 0F5F08CF146C7633000472A9 /* UnconditionalFinalizer.h in Headers */,
</span><span class="cx"> 0F666EC71835672B00D017F1 /* DFGAvailability.h in Headers */,
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLAbbreviationsh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLAbbreviations.h (164388 => 164389)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLAbbreviations.h 2014-02-19 21:57:41 UTC (rev 164388)
+++ trunk/Source/JavaScriptCore/ftl/FTLAbbreviations.h 2014-02-19 22:29:43 UTC (rev 164389)
</span><span class="lines">@@ -31,7 +31,6 @@
</span><span class="cx"> #if ENABLE(FTL_JIT)
</span><span class="cx">
</span><span class="cx"> #include "FTLAbbreviatedTypes.h"
</span><del>-#include "FTLSwitchCase.h"
</del><span class="cx"> #include "FTLValueFromBlock.h"
</span><span class="cx"> #include "LLVMAPI.h"
</span><span class="cx"> #include <cstring>
</span><span class="lines">@@ -120,6 +119,8 @@
</span><span class="cx"> static inline LValue mdString(LContext context, const char* string, unsigned length) { return llvm->MDStringInContext(context, string, length); }
</span><span class="cx"> static inline LValue mdString(LContext context, const char* string) { return mdString(context, string, std::strlen(string)); }
</span><span class="cx"> static inline LValue mdNode(LContext context, LValue* args, unsigned numArgs) { return llvm->MDNodeInContext(context, args, numArgs); }
</span><ins>+template<typename VectorType>
+static inline LValue mdNode(LContext context, const VectorType& vector) { return mdNode(context, const_cast<LValue*>(vector.begin()), vector.size()); }
</ins><span class="cx"> static inline LValue mdNode(LContext context) { return mdNode(context, 0, 0); }
</span><span class="cx"> static inline LValue mdNode(LContext context, LValue arg1) { return mdNode(context, &arg1, 1); }
</span><span class="cx"> static inline LValue mdNode(LContext context, LValue arg1, LValue arg2)
</span><span class="lines">@@ -127,6 +128,11 @@
</span><span class="cx"> LValue args[] = { arg1, arg2 };
</span><span class="cx"> return mdNode(context, args, 2);
</span><span class="cx"> }
</span><ins>+static inline LValue mdNode(LContext context, LValue arg1, LValue arg2, LValue arg3)
+{
+ LValue args[] = { arg1, arg2, arg3 };
+ return mdNode(context, args, 3);
+}
</ins><span class="cx">
</span><span class="cx"> static inline void setMetadata(LValue instruction, unsigned kind, LValue metadata) { llvm->SetMetadata(instruction, kind, metadata); }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLCommonValuescpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLCommonValues.cpp (164388 => 164389)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLCommonValues.cpp 2014-02-19 21:57:41 UTC (rev 164388)
+++ trunk/Source/JavaScriptCore/ftl/FTLCommonValues.cpp 2014-02-19 22:29:43 UTC (rev 164389)
</span><span class="lines">@@ -62,6 +62,8 @@
</span><span class="cx"> , intPtrPtr(constInt(intPtr, sizeof(void*), SignExtend))
</span><span class="cx"> , doubleZero(constReal(doubleType, 0))
</span><span class="cx"> , rangeKind(mdKindID(context, "range"))
</span><ins>+ , profKind(mdKindID(context, "prof"))
+ , branchWeights(mdString(context, "branch_weights"))
</ins><span class="cx"> , nonNegativeInt32(constInt(int32, 0, SignExtend), constInt(int32, 1ll << 31, SignExtend))
</span><span class="cx"> , m_context(context)
</span><span class="cx"> , m_module(0)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLCommonValuesh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLCommonValues.h (164388 => 164389)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLCommonValues.h 2014-02-19 21:57:41 UTC (rev 164388)
+++ trunk/Source/JavaScriptCore/ftl/FTLCommonValues.h 2014-02-19 22:29:43 UTC (rev 164389)
</span><span class="lines">@@ -76,9 +76,11 @@
</span><span class="cx"> const LValue doubleZero;
</span><span class="cx">
</span><span class="cx"> const unsigned rangeKind;
</span><ins>+ const unsigned profKind;
+ const LValue branchWeights;
</ins><span class="cx">
</span><span class="cx"> const ValueRange nonNegativeInt32;
</span><del>-
</del><ins>+
</ins><span class="cx"> LContext const m_context;
</span><span class="cx"> LModule m_module;
</span><span class="cx"> };
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLLowerDFGToLLVMcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp (164388 => 164389)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp 2014-02-19 21:57:41 UTC (rev 164388)
+++ trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToLLVM.cpp 2014-02-19 22:29:43 UTC (rev 164389)
</span><span class="lines">@@ -39,6 +39,7 @@
</span><span class="cx"> #include "FTLLoweredNodeValue.h"
</span><span class="cx"> #include "FTLOutput.h"
</span><span class="cx"> #include "FTLThunks.h"
</span><ins>+#include "FTLWeightedTarget.h"
</ins><span class="cx"> #include "LinkBuffer.h"
</span><span class="cx"> #include "OperandsInlines.h"
</span><span class="cx"> #include "JSCInlines.h"
</span><span class="lines">@@ -137,7 +138,7 @@
</span><span class="cx"> m_out.storePtr(m_out.constIntPtr(codeBlock()), addressFor(JSStack::CodeBlock));
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.below(m_callFrame, m_out.loadPtr(m_out.absolute(vm().addressOfFTLStackLimit()))),
</span><del>- stackOverflow, lowBlock(m_graph.block(0)));
</del><ins>+ rarely(stackOverflow), usually(lowBlock(m_graph.block(0))));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(stackOverflow, m_handleExceptions);
</span><span class="cx"> vmCall(m_out.operation(operationThrowStackOverflowError), m_callFrame, m_out.constIntPtr(codeBlock()), NoExceptions);
</span><span class="lines">@@ -626,7 +627,8 @@
</span><span class="cx">
</span><span class="cx"> Vector<ValueFromBlock> results;
</span><span class="cx">
</span><del>- m_out.branch(isNotInt32(value.value()), notIntCase, intCase);
</del><ins>+ m_out.branch(
+ isNotInt32(value.value()), unsure(notIntCase), unsure(intCase));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(intCase, notIntCase);
</span><span class="cx"> results.append(m_out.anchor(unboxInt32(value.value())));
</span><span class="lines">@@ -641,7 +643,9 @@
</span><span class="cx"> m_out.jump(continuation);
</span><span class="cx"> } else {
</span><span class="cx"> m_out.appendTo(notIntCase, doubleCase);
</span><del>- m_out.branch(isCellOrMisc(value.value()), notNumberCase, doubleCase);
</del><ins>+ m_out.branch(
+ isCellOrMisc(value.value()),
+ unsure(notNumberCase), unsure(doubleCase));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(doubleCase, notNumberCase);
</span><span class="cx"> results.append(m_out.anchor(doubleToInt32(unboxDouble(value.value()))));
</span><span class="lines">@@ -711,7 +715,7 @@
</span><span class="cx"> LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("Store barrier continuation"));
</span><span class="cx">
</span><span class="cx"> LValue base = lowJSValue(m_node->child1());
</span><del>- m_out.branch(m_out.isZero64(base), continuation, isNotNull);
</del><ins>+ m_out.branch(m_out.isZero64(base), unsure(continuation), unsure(isNotNull));
</ins><span class="cx"> LBasicBlock lastNext = m_out.appendTo(isNotNull, continuation);
</span><span class="cx"> emitStoreBarrier(base);
</span><span class="cx"> m_out.appendTo(continuation, lastNext);
</span><span class="lines">@@ -909,11 +913,11 @@
</span><span class="cx"> LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("ToThis slow case"));
</span><span class="cx"> LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ToThis continuation"));
</span><span class="cx">
</span><del>- m_out.branch(isCell(value), isCellCase, slowCase);
</del><ins>+ m_out.branch(isCell(value), usually(isCellCase), rarely(slowCase));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(isCellCase, slowCase);
</span><span class="cx"> ValueFromBlock fastResult = m_out.anchor(value);
</span><del>- m_out.branch(isType(value, FinalObjectType), continuation, slowCase);
</del><ins>+ m_out.branch(isType(value, FinalObjectType), usually(continuation), rarely(slowCase));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(slowCase, continuation);
</span><span class="cx"> J_JITOperation_EJ function;
</span><span class="lines">@@ -1077,7 +1081,8 @@
</span><span class="cx"> LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("ArithMul slow case"));
</span><span class="cx"> LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ArithMul continuation"));
</span><span class="cx">
</span><del>- m_out.branch(m_out.notZero32(result), continuation, slowCase);
</del><ins>+ m_out.branch(
+ m_out.notZero32(result), usually(continuation), rarely(slowCase));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(slowCase, continuation);
</span><span class="cx"> LValue cond = m_out.bitOr(m_out.lessThan(left, m_out.int32Zero), m_out.lessThan(right, m_out.int32Zero));
</span><span class="lines">@@ -1103,7 +1108,8 @@
</span><span class="cx"> LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("ArithMul slow case"));
</span><span class="cx"> LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ArithMul continuation"));
</span><span class="cx">
</span><del>- m_out.branch(m_out.notZero64(result), continuation, slowCase);
</del><ins>+ m_out.branch(
+ m_out.notZero64(result), usually(continuation), rarely(slowCase));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(slowCase, continuation);
</span><span class="cx"> LValue cond = m_out.bitOr(m_out.lessThan(left, m_out.int64Zero), m_out.lessThan(right, m_out.int64Zero));
</span><span class="lines">@@ -1143,7 +1149,9 @@
</span><span class="cx">
</span><span class="cx"> LValue adjustedDenominator = m_out.add(denominator, m_out.int32One);
</span><span class="cx">
</span><del>- m_out.branch(m_out.above(adjustedDenominator, m_out.int32One), continuation, unsafeDenominator);
</del><ins>+ m_out.branch(
+ m_out.above(adjustedDenominator, m_out.int32One),
+ usually(continuation), rarely(unsafeDenominator));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(unsafeDenominator, continuation);
</span><span class="cx">
</span><span class="lines">@@ -1163,14 +1171,17 @@
</span><span class="cx"> LBasicBlock notDivByZero = FTL_NEW_BLOCK(m_out, ("ArithDiv not divide by zero"));
</span><span class="cx"> LBasicBlock neg2ToThe31ByNeg1 = FTL_NEW_BLOCK(m_out, ("ArithDiv -2^31/-1"));
</span><span class="cx">
</span><del>- m_out.branch(m_out.isZero32(denominator), divByZero, notDivByZero);
</del><ins>+ m_out.branch(
+ m_out.isZero32(denominator), rarely(divByZero), usually(notDivByZero));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(divByZero, notDivByZero);
</span><span class="cx"> results.append(m_out.anchor(m_out.int32Zero));
</span><span class="cx"> m_out.jump(done);
</span><span class="cx">
</span><span class="cx"> m_out.appendTo(notDivByZero, neg2ToThe31ByNeg1);
</span><del>- m_out.branch(m_out.equal(numerator, neg2ToThe31), neg2ToThe31ByNeg1, continuation);
</del><ins>+ m_out.branch(
+ m_out.equal(numerator, neg2ToThe31),
+ rarely(neg2ToThe31ByNeg1), usually(continuation));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(neg2ToThe31ByNeg1, continuation);
</span><span class="cx"> results.append(m_out.anchor(neg2ToThe31));
</span><span class="lines">@@ -1183,7 +1194,9 @@
</span><span class="cx"> LBasicBlock zeroNumerator = FTL_NEW_BLOCK(m_out, ("ArithDiv zero numerator"));
</span><span class="cx"> LBasicBlock numeratorContinuation = FTL_NEW_BLOCK(m_out, ("ArithDiv numerator continuation"));
</span><span class="cx">
</span><del>- m_out.branch(m_out.isZero32(numerator), zeroNumerator, numeratorContinuation);
</del><ins>+ m_out.branch(
+ m_out.isZero32(numerator),
+ rarely(zeroNumerator), usually(numeratorContinuation));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock innerLastNext = m_out.appendTo(zeroNumerator, numeratorContinuation);
</span><span class="cx">
</span><span class="lines">@@ -1239,7 +1252,9 @@
</span><span class="cx">
</span><span class="cx"> LValue adjustedDenominator = m_out.add(denominator, m_out.int32One);
</span><span class="cx">
</span><del>- m_out.branch(m_out.above(adjustedDenominator, m_out.int32One), continuation, unsafeDenominator);
</del><ins>+ m_out.branch(
+ m_out.above(adjustedDenominator, m_out.int32One),
+ usually(continuation), rarely(unsafeDenominator));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(unsafeDenominator, continuation);
</span><span class="cx">
</span><span class="lines">@@ -1261,14 +1276,17 @@
</span><span class="cx"> LBasicBlock notModByZero = FTL_NEW_BLOCK(m_out, ("ArithMod not modulo by zero"));
</span><span class="cx"> LBasicBlock neg2ToThe31ByNeg1 = FTL_NEW_BLOCK(m_out, ("ArithMod -2^31/-1"));
</span><span class="cx">
</span><del>- m_out.branch(m_out.isZero32(denominator), modByZero, notModByZero);
</del><ins>+ m_out.branch(
+ m_out.isZero32(denominator), rarely(modByZero), usually(notModByZero));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(modByZero, notModByZero);
</span><span class="cx"> results.append(m_out.anchor(m_out.int32Zero));
</span><span class="cx"> m_out.jump(done);
</span><span class="cx">
</span><span class="cx"> m_out.appendTo(notModByZero, neg2ToThe31ByNeg1);
</span><del>- m_out.branch(m_out.equal(numerator, neg2ToThe31), neg2ToThe31ByNeg1, continuation);
</del><ins>+ m_out.branch(
+ m_out.equal(numerator, neg2ToThe31),
+ rarely(neg2ToThe31ByNeg1), usually(continuation));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(neg2ToThe31ByNeg1, continuation);
</span><span class="cx"> results.append(m_out.anchor(m_out.int32Zero));
</span><span class="lines">@@ -1285,7 +1303,7 @@
</span><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.lessThan(numerator, m_out.int32Zero),
</span><del>- negativeNumerator, numeratorContinuation);
</del><ins>+ unsure(negativeNumerator), unsure(numeratorContinuation));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock innerLastNext = m_out.appendTo(negativeNumerator, numeratorContinuation);
</span><span class="cx">
</span><span class="lines">@@ -1347,7 +1365,7 @@
</span><span class="cx"> m_node->op() == ArithMin
</span><span class="cx"> ? m_out.doubleLessThan(left, right)
</span><span class="cx"> : m_out.doubleGreaterThan(left, right),
</span><del>- continuation, notLessThan);
</del><ins>+ unsure(continuation), unsure(notLessThan));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(notLessThan, continuation);
</span><span class="cx"> results.append(m_out.anchor(m_out.select(
</span><span class="lines">@@ -1535,7 +1553,7 @@
</span><span class="cx"> LBasicBlock nextStructure = FTL_NEW_BLOCK(m_out, ("CheckStructure nextStructure"));
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.equal(structure, weakPointer(m_node->structureSet()[i])),
</span><del>- continuation, nextStructure);
</del><ins>+ unsure(continuation), unsure(nextStructure));
</ins><span class="cx"> m_out.appendTo(nextStructure);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1585,7 +1603,7 @@
</span><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.notEqual(structure, weakPointer(m_node->structure())),
</span><del>- unexpectedStructure, continuation);
</del><ins>+ rarely(unexpectedStructure), usually(continuation));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(unexpectedStructure, continuation);
</span><span class="cx">
</span><span class="lines">@@ -1669,7 +1687,7 @@
</span><span class="cx"> LBasicBlock notCellCase = FTL_NEW_BLOCK(m_out, ("GetById untyped not cell case"));
</span><span class="cx"> LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("GetById untyped continuation"));
</span><span class="cx">
</span><del>- m_out.branch(isCell(value), cellCase, notCellCase);
</del><ins>+ m_out.branch(isCell(value), unsure(cellCase), unsure(notCellCase));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(cellCase, notCellCase);
</span><span class="cx"> ValueFromBlock cellResult = m_out.anchor(getById(value));
</span><span class="lines">@@ -1741,7 +1759,8 @@
</span><span class="cx"> ValueFromBlock fastResult = m_out.anchor(
</span><span class="cx"> m_out.loadPtr(cell, m_heaps.JSString_value));
</span><span class="cx">
</span><del>- m_out.branch(m_out.notNull(fastResult.value()), continuation, slowPath);
</del><ins>+ m_out.branch(
+ m_out.notNull(fastResult.value()), usually(continuation), rarely(slowPath));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(slowPath, continuation);
</span><span class="cx">
</span><span class="lines">@@ -1781,7 +1800,9 @@
</span><span class="cx"> LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("continuation branch"));
</span><span class="cx">
</span><span class="cx"> LValue baseAddress = m_out.addPtr(basePtr, JSArrayBufferView::offsetOfMode());
</span><del>- m_out.branch(m_out.notEqual(baseAddress , m_out.constIntPtr(WastefulTypedArray)), simpleCase, wastefulCase);
</del><ins>+ m_out.branch(
+ m_out.notEqual(baseAddress , m_out.constIntPtr(WastefulTypedArray)),
+ unsure(simpleCase), unsure(wastefulCase));
</ins><span class="cx">
</span><span class="cx"> // begin simple case
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(simpleCase, wastefulCase);
</span><span class="lines">@@ -1875,13 +1896,14 @@
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.aboveOrEqual(
</span><span class="cx"> index, m_out.load32NonNegative(storage, m_heaps.Butterfly_publicLength)),
</span><del>- slowCase, fastCase);
</del><ins>+ rarely(slowCase), usually(fastCase));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(fastCase, slowCase);
</span><span class="cx">
</span><span class="cx"> ValueFromBlock fastResult = m_out.anchor(
</span><span class="cx"> m_out.load64(baseIndex(heap, storage, index, m_node->child2())));
</span><del>- m_out.branch(m_out.isZero64(fastResult.value()), slowCase, continuation);
</del><ins>+ m_out.branch(
+ m_out.isZero64(fastResult.value()), rarely(slowCase), usually(continuation));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(slowCase, continuation);
</span><span class="cx"> ValueFromBlock slowResult = m_out.anchor(
</span><span class="lines">@@ -1922,13 +1944,14 @@
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.aboveOrEqual(
</span><span class="cx"> index, m_out.load32NonNegative(storage, m_heaps.Butterfly_publicLength)),
</span><del>- slowCase, inBounds);
</del><ins>+ rarely(slowCase), usually(inBounds));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(inBounds, boxPath);
</span><span class="cx"> LValue doubleValue = m_out.loadDouble(
</span><span class="cx"> baseIndex(heap, storage, index, m_node->child2()));
</span><span class="cx"> m_out.branch(
</span><del>- m_out.doubleNotEqualOrUnordered(doubleValue, doubleValue), slowCase, boxPath);
</del><ins>+ m_out.doubleNotEqualOrUnordered(doubleValue, doubleValue),
+ rarely(slowCase), usually(boxPath));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(boxPath, slowCase);
</span><span class="cx"> ValueFromBlock fastResult = m_out.anchor(boxDouble(doubleValue));
</span><span class="lines">@@ -2181,7 +2204,7 @@
</span><span class="cx"> intValues.append(m_out.anchor(m_out.int32Zero));
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.lessThan(intValue, m_out.int32Zero),
</span><del>- continuation, atLeastZero);
</del><ins>+ unsure(continuation), unsure(atLeastZero));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(atLeastZero, continuation);
</span><span class="cx">
</span><span class="lines">@@ -2211,13 +2234,13 @@
</span><span class="cx"> intValues.append(m_out.anchor(m_out.int32Zero));
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.doubleLessThanOrUnordered(doubleValue, m_out.doubleZero),
</span><del>- continuation, atLeastZero);
</del><ins>+ unsure(continuation), unsure(atLeastZero));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(atLeastZero, withinRange);
</span><span class="cx"> intValues.append(m_out.anchor(m_out.constInt32(255)));
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.doubleGreaterThan(doubleValue, m_out.constDouble(255)),
</span><del>- continuation, withinRange);
</del><ins>+ unsure(continuation), unsure(withinRange));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(withinRange, continuation);
</span><span class="cx"> intValues.append(m_out.anchor(m_out.fpToInt32(doubleValue)));
</span><span class="lines">@@ -2274,7 +2297,7 @@
</span><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.aboveOrEqual(index, lowInt32(child5)),
</span><del>- continuation, isInBounds);
</del><ins>+ unsure(continuation), unsure(isInBounds));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(isInBounds, continuation);
</span><span class="cx"> m_out.store(valueToStore, pointer, refType);
</span><span class="lines">@@ -2329,7 +2352,7 @@
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.aboveOrEqual(
</span><span class="cx"> prevLength, m_out.load32(storage, m_heaps.Butterfly_vectorLength)),
</span><del>- slowPath, fastPath);
</del><ins>+ rarely(slowPath), usually(fastPath));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(fastPath, slowPath);
</span><span class="cx"> m_out.store(
</span><span class="lines">@@ -2382,7 +2405,8 @@
</span><span class="cx">
</span><span class="cx"> Vector<ValueFromBlock, 3> results;
</span><span class="cx"> results.append(m_out.anchor(m_out.constInt64(JSValue::encode(jsUndefined()))));
</span><del>- m_out.branch(m_out.isZero32(prevLength), continuation, fastCase);
</del><ins>+ m_out.branch(
+ m_out.isZero32(prevLength), rarely(continuation), usually(fastCase));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(fastCase, slowCase);
</span><span class="cx"> LValue newLength = m_out.sub(prevLength, m_out.int32One);
</span><span class="lines">@@ -2393,12 +2417,15 @@
</span><span class="cx"> LValue result = m_out.load64(pointer);
</span><span class="cx"> m_out.store64(m_out.int64Zero, pointer);
</span><span class="cx"> results.append(m_out.anchor(result));
</span><del>- m_out.branch(m_out.notZero64(result), continuation, slowCase);
</del><ins>+ m_out.branch(
+ m_out.notZero64(result), usually(continuation), rarely(slowCase));
</ins><span class="cx"> } else {
</span><span class="cx"> LValue result = m_out.loadDouble(pointer);
</span><span class="cx"> m_out.store64(m_out.constInt64(bitwise_cast<int64_t>(QNaN)), pointer);
</span><span class="cx"> results.append(m_out.anchor(boxDouble(result)));
</span><del>- m_out.branch(m_out.doubleEqual(result, result), continuation, slowCase);
</del><ins>+ m_out.branch(
+ m_out.doubleEqual(result, result),
+ usually(continuation), rarely(slowCase));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> m_out.appendTo(slowCase, continuation);
</span><span class="lines">@@ -2588,7 +2615,7 @@
</span><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.aboveOrEqual(publicLength, m_out.constInt32(MIN_SPARSE_ARRAY_INDEX)),
</span><del>- largeCase, fastCase);
</del><ins>+ rarely(largeCase), usually(fastCase));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(fastCase, largeCase);
</span><span class="cx">
</span><span class="lines">@@ -2617,7 +2644,8 @@
</span><span class="cx">
</span><span class="cx"> ValueFromBlock originalIndex = m_out.anchor(vectorLength);
</span><span class="cx"> ValueFromBlock originalPointer = m_out.anchor(butterfly);
</span><del>- m_out.branch(m_out.notZero32(vectorLength), initLoop, initDone);
</del><ins>+ m_out.branch(
+ m_out.notZero32(vectorLength), unsure(initLoop), unsure(initDone));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock initLastNext = m_out.appendTo(initLoop, initDone);
</span><span class="cx"> LValue index = m_out.phi(m_out.int32, originalIndex);
</span><span class="lines">@@ -2630,7 +2658,8 @@
</span><span class="cx"> LValue nextIndex = m_out.sub(index, m_out.int32One);
</span><span class="cx"> addIncoming(index, m_out.anchor(nextIndex));
</span><span class="cx"> addIncoming(pointer, m_out.anchor(m_out.add(pointer, m_out.intPtrEight)));
</span><del>- m_out.branch(m_out.notZero32(nextIndex), initLoop, initDone);
</del><ins>+ m_out.branch(
+ m_out.notZero32(nextIndex), unsure(initLoop), unsure(initDone));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(initDone, initLastNext);
</span><span class="cx"> }
</span><span class="lines">@@ -2792,7 +2821,7 @@
</span><span class="cx"> ValueFromBlock simpleResult = m_out.anchor(cell);
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.equal(structure, m_out.constIntPtr(vm().stringStructure.get())),
</span><del>- continuation, notString);
</del><ins>+ unsure(continuation), unsure(notString));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(notString, continuation);
</span><span class="cx"> speculateStringObjectForStructure(m_node->child1(), structure);
</span><span class="lines">@@ -2824,7 +2853,7 @@
</span><span class="cx"> isCellPredicate = m_out.booleanTrue;
</span><span class="cx"> else
</span><span class="cx"> isCellPredicate = this->isCell(value);
</span><del>- m_out.branch(isCellPredicate, isCell, notString);
</del><ins>+ m_out.branch(isCellPredicate, unsure(isCell), unsure(notString));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(isCell, notString);
</span><span class="cx"> ValueFromBlock simpleResult = m_out.anchor(value);
</span><span class="lines">@@ -2835,7 +2864,7 @@
</span><span class="cx"> m_out.constIntPtr(vm().stringStructure.get()));
</span><span class="cx"> } else
</span><span class="cx"> isStringPredicate = m_out.booleanFalse;
</span><del>- m_out.branch(isStringPredicate, continuation, notString);
</del><ins>+ m_out.branch(isStringPredicate, unsure(continuation), unsure(notString));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(notString, continuation);
</span><span class="cx"> LValue operation;
</span><span class="lines">@@ -2868,11 +2897,11 @@
</span><span class="cx"> Vector<ValueFromBlock, 3> results;
</span><span class="cx">
</span><span class="cx"> results.append(m_out.anchor(value));
</span><del>- m_out.branch(isCell(value), isCellCase, continuation);
</del><ins>+ m_out.branch(isCell(value), unsure(isCellCase), unsure(continuation));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(isCellCase, isObjectCase);
</span><span class="cx"> results.append(m_out.anchor(value));
</span><del>- m_out.branch(isObject(value), isObjectCase, continuation);
</del><ins>+ m_out.branch(isObject(value), unsure(isObjectCase), unsure(continuation));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(isObjectCase, continuation);
</span><span class="cx"> results.append(m_out.anchor(vmCall(
</span><span class="lines">@@ -2963,7 +2992,7 @@
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.aboveOrEqual(
</span><span class="cx"> index, m_out.load32NonNegative(base, m_heaps.JSString_length)),
</span><del>- slowPath, fastPath);
</del><ins>+ rarely(slowPath), usually(fastPath));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(fastPath, slowPath);
</span><span class="cx">
</span><span class="lines">@@ -2978,7 +3007,7 @@
</span><span class="cx"> m_out.testIsZero32(
</span><span class="cx"> m_out.load32(stringImpl, m_heaps.StringImpl_hashAndFlags),
</span><span class="cx"> m_out.constInt32(StringImpl::flagIs8Bit())),
</span><del>- is16Bit, is8Bit);
</del><ins>+ unsure(is16Bit), unsure(is8Bit));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(is8Bit, is16Bit);
</span><span class="cx">
</span><span class="lines">@@ -2998,7 +3027,9 @@
</span><span class="cx"> storage, m_out.zeroExt(index, m_out.intPtr),
</span><span class="cx"> m_state.forNode(m_node->child2()).m_value)),
</span><span class="cx"> m_out.int32));
</span><del>- m_out.branch(m_out.aboveOrEqual(char16Bit.value(), m_out.constInt32(0x100)), bigCharacter, bitsContinuation);
</del><ins>+ m_out.branch(
+ m_out.aboveOrEqual(char16Bit.value(), m_out.constInt32(0x100)),
+ rarely(bigCharacter), usually(bitsContinuation));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(bigCharacter, bitsContinuation);
</span><span class="cx">
</span><span class="lines">@@ -3031,7 +3062,9 @@
</span><span class="cx"> LBasicBlock negativeIndex = FTL_NEW_BLOCK(m_out, ("GetByVal String negative index"));
</span><span class="cx">
</span><span class="cx"> results.append(m_out.anchor(m_out.constInt64(JSValue::encode(jsUndefined()))));
</span><del>- m_out.branch(m_out.lessThan(index, m_out.int32Zero), negativeIndex, continuation);
</del><ins>+ m_out.branch(
+ m_out.lessThan(index, m_out.int32Zero),
+ rarely(negativeIndex), usually(continuation));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(negativeIndex, continuation);
</span><span class="cx"> }
</span><span class="lines">@@ -3067,7 +3100,7 @@
</span><span class="cx"> m_out.testIsZero32(
</span><span class="cx"> m_out.load32(stringImpl, m_heaps.StringImpl_hashAndFlags),
</span><span class="cx"> m_out.constInt32(StringImpl::flagIs8Bit())),
</span><del>- is16Bit, is8Bit);
</del><ins>+ unsure(is16Bit), unsure(is8Bit));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(is8Bit, is16Bit);
</span><span class="cx">
</span><span class="lines">@@ -3122,10 +3155,13 @@
</span><span class="cx"> Vector<SwitchCase, 2> cases;
</span><span class="cx"> for (unsigned i = data.variants.size(); i--;) {
</span><span class="cx"> GetByIdVariant variant = data.variants[i];
</span><del>- for (unsigned j = variant.structureSet().size(); j--;)
- cases.append(SwitchCase(weakPointer(variant.structureSet()[j]), blocks[i]));
</del><ins>+ for (unsigned j = variant.structureSet().size(); j--;) {
+ cases.append(SwitchCase(
+ weakPointer(variant.structureSet()[j]), blocks[i], Weight(1)));
+ }
</ins><span class="cx"> }
</span><del>- m_out.switchInstruction(m_out.loadPtr(base, m_heaps.JSCell_structure), cases, exit);
</del><ins>+ m_out.switchInstruction(
+ m_out.loadPtr(base, m_heaps.JSCell_structure), cases, exit, Weight(0));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.m_nextBlock;
</span><span class="cx">
</span><span class="lines">@@ -3206,7 +3242,7 @@
</span><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.equal(state, m_out.constInt8(IsInvalidated)),
</span><del>- continuation, isNotInvalidated);
</del><ins>+ usually(continuation), rarely(isNotInvalidated));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(isNotInvalidated, isClear);
</span><span class="cx">
</span><span class="lines">@@ -3215,7 +3251,7 @@
</span><span class="cx"> isClearValue = m_out.equal(state, m_out.constInt8(ClearWatchpoint));
</span><span class="cx"> else
</span><span class="cx"> isClearValue = m_out.booleanFalse;
</span><del>- m_out.branch(isClearValue, isClear, isWatched);
</del><ins>+ m_out.branch(isClearValue, unsure(isClear), unsure(isWatched));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(isClear, isWatched);
</span><span class="cx">
</span><span class="lines">@@ -3227,13 +3263,13 @@
</span><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.equal(value, m_out.load64(m_out.absolute(set->addressOfInferredValue()))),
</span><del>- continuation, invalidate);
</del><ins>+ unsure(continuation), unsure(invalidate));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(invalidate, invalidateFast);
</span><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.notZero8(m_out.load8(m_out.absolute(set->addressOfSetIsNotEmpty()))),
</span><del>- invalidateSlow, invalidateFast);
</del><ins>+ rarely(invalidateSlow), usually(invalidateFast));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(invalidateFast, invalidateSlow);
</span><span class="cx">
</span><span class="lines">@@ -3456,14 +3492,20 @@
</span><span class="cx">
</span><span class="cx"> void compileBranch()
</span><span class="cx"> {
</span><ins>+ // FIXME: DFG should be able to tell us branch weights here.
+ // https://bugs.webkit.org/show_bug.cgi?id=129055
+
</ins><span class="cx"> m_out.branch(
</span><span class="cx"> boolify(m_node->child1()),
</span><del>- lowBlock(m_node->takenBlock()),
- lowBlock(m_node->notTakenBlock()));
</del><ins>+ unsure(lowBlock(m_node->takenBlock())),
+ unsure(lowBlock(m_node->notTakenBlock())));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void compileSwitch()
</span><span class="cx"> {
</span><ins>+ // FIXME: DFG should be able to tell us branch weights here.
+ // https://bugs.webkit.org/show_bug.cgi?id=129055
+
</ins><span class="cx"> SwitchData* data = m_node->switchData();
</span><span class="cx"> switch (data->kind) {
</span><span class="cx"> case SwitchImm: {
</span><span class="lines">@@ -3485,7 +3527,7 @@
</span><span class="cx"> LBasicBlock isDouble = FTL_NEW_BLOCK(m_out, ("Switch/SwitchImm is double"));
</span><span class="cx">
</span><span class="cx"> LValue boxedValue = lowJSValue(m_node->child1());
</span><del>- m_out.branch(isNotInt32(boxedValue), isNotInt, isInt);
</del><ins>+ m_out.branch(isNotInt32(boxedValue), unsure(isNotInt), unsure(isInt));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock innerLastNext = m_out.appendTo(isInt, isNotInt);
</span><span class="cx">
</span><span class="lines">@@ -3494,7 +3536,8 @@
</span><span class="cx">
</span><span class="cx"> m_out.appendTo(isNotInt, isDouble);
</span><span class="cx"> m_out.branch(
</span><del>- isCellOrMisc(boxedValue), lowBlock(data->fallThrough), isDouble);
</del><ins>+ isCellOrMisc(boxedValue),
+ usually(lowBlock(data->fallThrough)), rarely(isDouble));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(isDouble, innerLastNext);
</span><span class="cx"> LValue doubleValue = unboxDouble(boxedValue);
</span><span class="lines">@@ -3502,7 +3545,7 @@
</span><span class="cx"> intValues.append(m_out.anchor(intInDouble));
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.doubleEqual(m_out.intToDouble(intInDouble), doubleValue),
</span><del>- switchOnInts, lowBlock(data->fallThrough));
</del><ins>+ unsure(switchOnInts), unsure(lowBlock(data->fallThrough)));
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -3532,11 +3575,14 @@
</span><span class="cx"> LBasicBlock isStringCase = FTL_NEW_BLOCK(m_out, ("Switch/SwitchChar is string"));
</span><span class="cx">
</span><span class="cx"> m_out.branch(
</span><del>- isNotCell(unboxedValue), lowBlock(data->fallThrough), isCellCase);
</del><ins>+ isNotCell(unboxedValue),
+ unsure(lowBlock(data->fallThrough)), unsure(isCellCase));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(isCellCase, isStringCase);
</span><span class="cx"> LValue cellValue = unboxedValue;
</span><del>- m_out.branch(isNotString(cellValue), lowBlock(data->fallThrough), isStringCase);
</del><ins>+ m_out.branch(
+ isNotString(cellValue),
+ unsure(lowBlock(data->fallThrough)), unsure(isStringCase));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(isStringCase, lastNext);
</span><span class="cx"> stringValue = cellValue;
</span><span class="lines">@@ -3559,13 +3605,13 @@
</span><span class="cx"> m_out.notEqual(
</span><span class="cx"> m_out.load32NonNegative(stringValue, m_heaps.JSString_length),
</span><span class="cx"> m_out.int32One),
</span><del>- lowBlock(data->fallThrough), lengthIs1);
</del><ins>+ unsure(lowBlock(data->fallThrough)), unsure(lengthIs1));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(lengthIs1, needResolution);
</span><span class="cx"> Vector<ValueFromBlock, 2> values;
</span><span class="cx"> LValue fastValue = m_out.loadPtr(stringValue, m_heaps.JSString_value);
</span><span class="cx"> values.append(m_out.anchor(fastValue));
</span><del>- m_out.branch(m_out.isNull(fastValue), needResolution, resolved);
</del><ins>+ m_out.branch(m_out.isNull(fastValue), rarely(needResolution), usually(resolved));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(needResolution, resolved);
</span><span class="cx"> values.append(m_out.anchor(
</span><span class="lines">@@ -3579,7 +3625,7 @@
</span><span class="cx"> m_out.testNonZero32(
</span><span class="cx"> m_out.load32(value, m_heaps.StringImpl_hashAndFlags),
</span><span class="cx"> m_out.constInt32(StringImpl::flagIs8Bit())),
</span><del>- is8Bit, is16Bit);
</del><ins>+ unsure(is8Bit), unsure(is16Bit));
</ins><span class="cx">
</span><span class="cx"> Vector<ValueFromBlock, 2> characters;
</span><span class="cx"> m_out.appendTo(is8Bit, is16Bit);
</span><span class="lines">@@ -3727,7 +3773,7 @@
</span><span class="cx"> LBasicBlock leftNotCellCase = FTL_NEW_BLOCK(m_out, ("CompareEqObjectOrOtherToObject left not cell case"));
</span><span class="cx"> LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("CompareEqObjectOrOtherToObject continuation"));
</span><span class="cx">
</span><del>- m_out.branch(isCell(leftValue), leftCellCase, leftNotCellCase);
</del><ins>+ m_out.branch(isCell(leftValue), unsure(leftCellCase), unsure(leftNotCellCase));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(leftCellCase, leftNotCellCase);
</span><span class="cx"> speculateTruthyObject(leftChild, leftValue, SpecObject | (~SpecCell));
</span><span class="lines">@@ -3772,10 +3818,10 @@
</span><span class="cx"> LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("CompareEq untyped slow path"));
</span><span class="cx"> LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("CompareEq untyped continuation"));
</span><span class="cx">
</span><del>- m_out.branch(isNotInt32(left), slowPath, leftIsInt);
</del><ins>+ m_out.branch(isNotInt32(left), rarely(slowPath), usually(leftIsInt));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(leftIsInt, fastPath);
</span><del>- m_out.branch(isNotInt32(right), slowPath, fastPath);
</del><ins>+ m_out.branch(isNotInt32(right), rarely(slowPath), usually(fastPath));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(fastPath, slowPath);
</span><span class="cx"> ValueFromBlock fastResult = m_out.anchor(
</span><span class="lines">@@ -3798,7 +3844,7 @@
</span><span class="cx"> LValue result = m_out.loadPtr(
</span><span class="cx"> allocator, m_heaps.MarkedAllocator_freeListHead);
</span><span class="cx">
</span><del>- m_out.branch(m_out.notNull(result), success, slowPath);
</del><ins>+ m_out.branch(m_out.notNull(result), usually(success), rarely(slowPath));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(success);
</span><span class="cx">
</span><span class="lines">@@ -3843,7 +3889,9 @@
</span><span class="cx"> LValue remaining = m_out.loadPtr(m_out.absolute(&allocator.m_currentRemaining));
</span><span class="cx"> LValue newRemaining = m_out.sub(remaining, size);
</span><span class="cx">
</span><del>- m_out.branch(m_out.lessThan(newRemaining, m_out.intPtrZero), slowPath, success);
</del><ins>+ m_out.branch(
+ m_out.lessThan(newRemaining, m_out.intPtrZero),
+ rarely(slowPath), usually(success));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(success);
</span><span class="cx">
</span><span class="lines">@@ -3971,7 +4019,7 @@
</span><span class="cx"> LBasicBlock fastCase = FTL_NEW_BLOCK(m_out, ("Boolify untyped fast case"));
</span><span class="cx"> LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("Boolify untyped continuation"));
</span><span class="cx">
</span><del>- m_out.branch(isNotBoolean(value), slowCase, fastCase);
</del><ins>+ m_out.branch(isNotBoolean(value), rarely(slowCase), usually(fastCase));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(fastCase, slowCase);
</span><span class="cx"> ValueFromBlock fastResult = m_out.anchor(unboxBoolean(value));
</span><span class="lines">@@ -4013,7 +4061,7 @@
</span><span class="cx"> LBasicBlock primitiveCase = FTL_NEW_BLOCK(m_out, ("EqualNullOrUndefined primitive case"));
</span><span class="cx"> LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("EqualNullOrUndefined continuation"));
</span><span class="cx">
</span><del>- m_out.branch(isNotCell(value), primitiveCase, cellCase);
</del><ins>+ m_out.branch(isNotCell(value), unsure(primitiveCase), unsure(cellCase));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(cellCase, primitiveCase);
</span><span class="cx">
</span><span class="lines">@@ -4046,7 +4094,7 @@
</span><span class="cx"> m_out.testNonZero8(
</span><span class="cx"> m_out.load8(structure, m_heaps.Structure_typeInfoFlags),
</span><span class="cx"> m_out.constInt8(MasqueradesAsUndefined)),
</span><del>- masqueradesCase, continuation);
</del><ins>+ rarely(masqueradesCase), usually(continuation));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(masqueradesCase, primitiveCase);
</span><span class="cx">
</span><span class="lines">@@ -4097,7 +4145,7 @@
</span><span class="cx"> LBasicBlock performStore =
</span><span class="cx"> FTL_NEW_BLOCK(m_out, ("PutByVal perform store"));
</span><span class="cx">
</span><del>- m_out.branch(isNotInBounds, notInBoundsCase, performStore);
</del><ins>+ m_out.branch(isNotInBounds, unsure(notInBoundsCase), unsure(performStore));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(notInBoundsCase, performStore);
</span><span class="cx">
</span><span class="lines">@@ -4112,7 +4160,7 @@
</span><span class="cx"> LBasicBlock holeCase =
</span><span class="cx"> FTL_NEW_BLOCK(m_out, ("PutByVal hole case"));
</span><span class="cx">
</span><del>- m_out.branch(isOutOfBounds, outOfBoundsCase, holeCase);
</del><ins>+ m_out.branch(isOutOfBounds, unsure(outOfBoundsCase), unsure(holeCase));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock innerLastNext = m_out.appendTo(outOfBoundsCase, holeCase);
</span><span class="cx">
</span><span class="lines">@@ -4140,10 +4188,10 @@
</span><span class="cx"> for (unsigned i = 0; i < data->cases.size(); ++i) {
</span><span class="cx"> cases.append(SwitchCase(
</span><span class="cx"> constInt(type, data->cases[i].value.switchLookupValue()),
</span><del>- lowBlock(data->cases[i].target)));
</del><ins>+ lowBlock(data->cases[i].target), Weight()));
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- m_out.switchInstruction(switchValue, cases, lowBlock(data->fallThrough));
</del><ins>+ m_out.switchInstruction(switchValue, cases, lowBlock(data->fallThrough), Weight());
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> LValue doubleToInt32(LValue doubleValue, double low, double high, bool isSigned = true)
</span><span class="lines">@@ -4160,12 +4208,12 @@
</span><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.doubleGreaterThanOrEqual(doubleValue, m_out.constDouble(low)),
</span><del>- greatEnough, slowPath);
</del><ins>+ unsure(greatEnough), unsure(slowPath));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(greatEnough, withinRange);
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.doubleLessThanOrEqual(doubleValue, m_out.constDouble(high)),
</span><del>- withinRange, slowPath);
</del><ins>+ unsure(withinRange), unsure(slowPath));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(withinRange, slowPath);
</span><span class="cx"> LValue fastResult;
</span><span class="lines">@@ -4202,7 +4250,7 @@
</span><span class="cx"> m_out.sensibleDoubleToInt(doubleValue));
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.equal(fastResult.value(), m_out.constInt32(0x80000000)),
</span><del>- slowPath, continuation);
</del><ins>+ rarely(slowPath), usually(continuation));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(slowPath, continuation);
</span><span class="cx"> ValueFromBlock slowResult = m_out.anchor(
</span><span class="lines">@@ -4510,7 +4558,7 @@
</span><span class="cx"> LBasicBlock doubleCase = FTL_NEW_BLOCK(m_out, ("Double unboxing double case"));
</span><span class="cx"> LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("Double unboxing continuation"));
</span><span class="cx">
</span><del>- m_out.branch(isNotInt32(boxedResult), doubleCase, intCase);
</del><ins>+ m_out.branch(isNotInt32(boxedResult), unsure(doubleCase), unsure(intCase));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(intCase, doubleCase);
</span><span class="cx">
</span><span class="lines">@@ -4622,7 +4670,7 @@
</span><span class="cx"> LValue int32Value = m_out.castToInt32(value);
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.equal(m_out.signExt(int32Value, m_out.int64), value),
</span><del>- isInt32, isDouble);
</del><ins>+ unsure(isInt32), unsure(isDouble));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(isInt32, isDouble);
</span><span class="cx">
</span><span class="lines">@@ -4913,7 +4961,7 @@
</span><span class="cx"> LBasicBlock primitiveCase = FTL_NEW_BLOCK(m_out, ("speculateObjectOrOther primitive case"));
</span><span class="cx"> LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("speculateObjectOrOther continuation"));
</span><span class="cx">
</span><del>- m_out.branch(isNotCell(value), primitiveCase, cellCase);
</del><ins>+ m_out.branch(isNotCell(value), unsure(primitiveCase), unsure(cellCase));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(cellCase, primitiveCase);
</span><span class="cx">
</span><span class="lines">@@ -4973,7 +5021,7 @@
</span><span class="cx"> LValue structure = m_out.loadPtr(lowCell(edge), m_heaps.JSCell_structure);
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.equal(structure, m_out.constIntPtr(vm().stringStructure.get())),
</span><del>- continuation, notString);
</del><ins>+ unsure(continuation), unsure(notString));
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(notString, continuation);
</span><span class="cx"> speculateStringObjectForStructure(edge, structure);
</span><span class="lines">@@ -5082,7 +5130,7 @@
</span><span class="cx"> LBasicBlock isCell = FTL_NEW_BLOCK(m_out, ("Store barrier is cell block"));
</span><span class="cx">
</span><span class="cx"> if (m_state.forNode(valueEdge.node()).couldBeType(SpecCell))
</span><del>- m_out.branch(isNotCell(value), continuation, isCell);
</del><ins>+ m_out.branch(isNotCell(value), unsure(continuation), unsure(isCell));
</ins><span class="cx"> else
</span><span class="cx"> m_out.jump(isCell);
</span><span class="cx">
</span><span class="lines">@@ -5107,13 +5155,16 @@
</span><span class="cx"> LBasicBlock bufferIsFull = FTL_NEW_BLOCK(m_out, ("Store barrier buffer is full"));
</span><span class="cx">
</span><span class="cx"> // Check the mark byte.
</span><del>- m_out.branch(m_out.isZero8(loadMarkByte(base)), continuation, isMarked);
</del><ins>+ m_out.branch(
+ m_out.isZero8(loadMarkByte(base)), usually(continuation), rarely(isMarked));
</ins><span class="cx">
</span><span class="cx"> // Append to the write barrier buffer.
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(isMarked, bufferHasSpace);
</span><span class="cx"> LValue currentBufferIndex = m_out.load32(m_out.absolute(&vm().heap.writeBarrierBuffer().m_currentIndex));
</span><span class="cx"> LValue bufferCapacity = m_out.load32(m_out.absolute(&vm().heap.writeBarrierBuffer().m_capacity));
</span><del>- m_out.branch(m_out.lessThan(currentBufferIndex, bufferCapacity), bufferHasSpace, bufferIsFull);
</del><ins>+ m_out.branch(
+ m_out.lessThan(currentBufferIndex, bufferCapacity),
+ usually(bufferHasSpace), rarely(bufferIsFull));
</ins><span class="cx">
</span><span class="cx"> // Buffer has space, store to it.
</span><span class="cx"> m_out.appendTo(bufferHasSpace, bufferIsFull);
</span><span class="lines">@@ -5193,7 +5244,7 @@
</span><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.notZero64(m_out.load64(m_out.absolute(vm().addressOfException()))),
</span><del>- m_handleExceptions, continuation);
</del><ins>+ rarely(m_handleExceptions), usually(continuation));
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(continuation);
</span><span class="cx"> }
</span><span class="lines">@@ -5233,7 +5284,7 @@
</span><span class="cx"> LBasicBlock failCase = FTL_NEW_BLOCK(m_out, ("OSR exit failCase for ", m_node));
</span><span class="cx"> continuation = FTL_NEW_BLOCK(m_out, ("OSR exit continuation for ", m_node));
</span><span class="cx">
</span><del>- m_out.branch(failCondition, failCase, continuation);
</del><ins>+ m_out.branch(failCondition, rarely(failCase), usually(continuation));
</ins><span class="cx">
</span><span class="cx"> lastNext = m_out.appendTo(failCase, continuation);
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLOutputcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLOutput.cpp (164388 => 164389)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLOutput.cpp 2014-02-19 21:57:41 UTC (rev 164388)
+++ trunk/Source/JavaScriptCore/ftl/FTLOutput.cpp 2014-02-19 22:29:43 UTC (rev 164389)
</span><span class="lines">@@ -45,6 +45,104 @@
</span><span class="cx"> llvm->DisposeBuilder(m_builder);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+void Output::initialize(LModule module, LValue function, AbstractHeapRepository& heaps)
+{
+ IntrinsicRepository::initialize(module);
+ m_function = function;
+ m_heaps = &heaps;
+}
+
+LBasicBlock Output::appendTo(LBasicBlock block, LBasicBlock nextBlock)
+{
+ appendTo(block);
+ return insertNewBlocksBefore(nextBlock);
+}
+
+void Output::appendTo(LBasicBlock block)
+{
+ m_block = block;
+
+ llvm->PositionBuilderAtEnd(m_builder, block);
+}
+
+LBasicBlock Output::newBlock(const char* name)
+{
+ if (!m_nextBlock)
+ return appendBasicBlock(m_context, m_function, name);
+ return insertBasicBlock(m_context, m_nextBlock, name);
+}
+
+LValue Output::sensibleDoubleToInt(LValue value)
+{
+ RELEASE_ASSERT(isX86());
+ return call(
+ x86SSE2CvtTSD2SIIntrinsic(),
+ insertElement(
+ insertElement(getUndef(vectorType(doubleType, 2)), value, int32Zero),
+ doubleZero, int32One));
+}
+
+LValue Output::load(TypedPointer pointer, LType refType)
+{
+ LValue result = get(intToPtr(pointer.value(), refType));
+ pointer.heap().decorateInstruction(result, *m_heaps);
+ return result;
+}
+
+void Output::store(LValue value, TypedPointer pointer, LType refType)
+{
+ LValue result = set(value, intToPtr(pointer.value(), refType));
+ pointer.heap().decorateInstruction(result, *m_heaps);
+}
+
+LValue Output::baseIndex(LValue base, LValue index, Scale scale, ptrdiff_t offset)
+{
+ LValue accumulatedOffset;
+
+ switch (scale) {
+ case ScaleOne:
+ accumulatedOffset = index;
+ break;
+ case ScaleTwo:
+ accumulatedOffset = shl(index, intPtrOne);
+ break;
+ case ScaleFour:
+ accumulatedOffset = shl(index, intPtrTwo);
+ break;
+ case ScaleEight:
+ case ScalePtr:
+ accumulatedOffset = shl(index, intPtrThree);
+ break;
+ }
+
+ if (offset)
+ accumulatedOffset = add(accumulatedOffset, constIntPtr(offset));
+
+ return add(base, accumulatedOffset);
+}
+
+void Output::branch(LValue condition, LBasicBlock taken, Weight takenWeight, LBasicBlock notTaken, Weight notTakenWeight)
+{
+ LValue branch = buildCondBr(m_builder, condition, taken, notTaken);
+
+ if (!takenWeight || !notTakenWeight)
+ return;
+
+ double total = takenWeight.value() + notTakenWeight.value();
+
+ setMetadata(
+ branch, profKind,
+ mdNode(
+ m_context, branchWeights,
+ constInt32(takenWeight.scaleToTotal(total)),
+ constInt32(notTakenWeight.scaleToTotal(total))));
+}
+
+void Output::crashNonTerminal()
+{
+ call(intToPtr(constIntPtr(abort), pointerType(functionType(voidType))));
+}
+
</ins><span class="cx"> } } // namespace JSC::FTL
</span><span class="cx">
</span><span class="cx"> #endif // ENABLE(FTL_JIT)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLOutputh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLOutput.h (164388 => 164389)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLOutput.h 2014-02-19 21:57:41 UTC (rev 164388)
+++ trunk/Source/JavaScriptCore/ftl/FTLOutput.h 2014-02-19 22:29:43 UTC (rev 164389)
</span><span class="lines">@@ -35,7 +35,10 @@
</span><span class="cx"> #include "FTLAbstractHeapRepository.h"
</span><span class="cx"> #include "FTLCommonValues.h"
</span><span class="cx"> #include "FTLIntrinsicRepository.h"
</span><ins>+#include "FTLSwitchCase.h"
</ins><span class="cx"> #include "FTLTypedPointer.h"
</span><ins>+#include "FTLWeight.h"
+#include "FTLWeightedTarget.h"
</ins><span class="cx"> #include <wtf/StringPrintStream.h>
</span><span class="cx">
</span><span class="cx"> namespace JSC { namespace FTL {
</span><span class="lines">@@ -70,12 +73,7 @@
</span><span class="cx"> Output(LContext);
</span><span class="cx"> ~Output();
</span><span class="cx">
</span><del>- void initialize(LModule module, LValue function, AbstractHeapRepository& heaps)
- {
- IntrinsicRepository::initialize(module);
- m_function = function;
- m_heaps = &heaps;
- }
</del><ins>+ void initialize(LModule, LValue, AbstractHeapRepository&);
</ins><span class="cx">
</span><span class="cx"> LBasicBlock insertNewBlocksBefore(LBasicBlock nextBlock)
</span><span class="cx"> {
</span><span class="lines">@@ -84,25 +82,12 @@
</span><span class="cx"> return lastNextBlock;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- LBasicBlock appendTo(LBasicBlock block, LBasicBlock nextBlock)
- {
- appendTo(block);
- return insertNewBlocksBefore(nextBlock);
- }
</del><ins>+ LBasicBlock appendTo(LBasicBlock, LBasicBlock nextBlock);
</ins><span class="cx">
</span><del>- void appendTo(LBasicBlock block)
- {
- m_block = block;
-
- llvm->PositionBuilderAtEnd(m_builder, block);
- }
- LBasicBlock newBlock(const char* name = "")
- {
- if (!m_nextBlock)
- return appendBasicBlock(m_context, m_function, name);
- return insertBasicBlock(m_context, m_nextBlock, name);
- }
</del><ins>+ void appendTo(LBasicBlock);
</ins><span class="cx">
</span><ins>+ LBasicBlock newBlock(const char* name = "");
+
</ins><span class="cx"> LValue param(unsigned index) { return getParam(m_function, index); }
</span><span class="cx"> LValue constBool(bool value) { return constInt(boolean, value); }
</span><span class="cx"> LValue constInt8(int8_t value) { return constInt(int8, value); }
</span><span class="lines">@@ -189,7 +174,6 @@
</span><span class="cx"> return call(doubleSinIntrinsic(), value);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-
</del><span class="cx"> LValue doubleCos(LValue value)
</span><span class="cx"> {
</span><span class="cx"> return call(doubleCosIntrinsic(), value);
</span><span class="lines">@@ -200,17 +184,8 @@
</span><span class="cx"> return call(doubleSqrtIntrinsic(), value);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-
</del><span class="cx"> static bool hasSensibleDoubleToInt() { return isX86(); }
</span><del>- LValue sensibleDoubleToInt(LValue value)
- {
- RELEASE_ASSERT(isX86());
- return call(
- x86SSE2CvtTSD2SIIntrinsic(),
- insertElement(
- insertElement(getUndef(vectorType(doubleType, 2)), value, int32Zero),
- doubleZero, int32One));
- }
</del><ins>+ LValue sensibleDoubleToInt(LValue);
</ins><span class="cx">
</span><span class="cx"> LValue signExt(LValue value, LType type) { return buildSExt(m_builder, value, type); }
</span><span class="cx"> LValue zeroExt(LValue value, LType type) { return buildZExt(m_builder, value, type); }
</span><span class="lines">@@ -233,17 +208,8 @@
</span><span class="cx"> LValue get(LValue reference) { return buildLoad(m_builder, reference); }
</span><span class="cx"> LValue set(LValue value, LValue reference) { return buildStore(m_builder, value, reference); }
</span><span class="cx">
</span><del>- LValue load(TypedPointer pointer, LType refType)
- {
- LValue result = get(intToPtr(pointer.value(), refType));
- pointer.heap().decorateInstruction(result, *m_heaps);
- return result;
- }
- void store(LValue value, TypedPointer pointer, LType refType)
- {
- LValue result = set(value, intToPtr(pointer.value(), refType));
- pointer.heap().decorateInstruction(result, *m_heaps);
- }
</del><ins>+ LValue load(TypedPointer, LType refType);
+ void store(LValue, TypedPointer, LType refType);
</ins><span class="cx">
</span><span class="cx"> LValue load8(TypedPointer pointer) { return load(pointer, ref8); }
</span><span class="cx"> LValue load16(TypedPointer pointer) { return load(pointer, ref16); }
</span><span class="lines">@@ -281,31 +247,8 @@
</span><span class="cx"> return address(field, base, offset + field.offset());
</span><span class="cx"> }
</span><span class="cx">
</span><del>- LValue baseIndex(LValue base, LValue index, Scale scale, ptrdiff_t offset = 0)
- {
- LValue accumulatedOffset;
-
- switch (scale) {
- case ScaleOne:
- accumulatedOffset = index;
- break;
- case ScaleTwo:
- accumulatedOffset = shl(index, intPtrOne);
- break;
- case ScaleFour:
- accumulatedOffset = shl(index, intPtrTwo);
- break;
- case ScaleEight:
- case ScalePtr:
- accumulatedOffset = shl(index, intPtrThree);
- break;
- }
-
- if (offset)
- accumulatedOffset = add(accumulatedOffset, constIntPtr(offset));
-
- return add(base, accumulatedOffset);
- }
</del><ins>+ LValue baseIndex(LValue base, LValue index, Scale, ptrdiff_t offset = 0);
+
</ins><span class="cx"> TypedPointer baseIndex(const AbstractHeap& heap, LValue base, LValue index, Scale scale, ptrdiff_t offset = 0)
</span><span class="cx"> {
</span><span class="cx"> return TypedPointer(heap, baseIndex(base, index, scale, offset));
</span><span class="lines">@@ -412,9 +355,36 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void jump(LBasicBlock destination) { buildBr(m_builder, destination); }
</span><del>- void branch(LValue condition, LBasicBlock taken, LBasicBlock notTaken) { buildCondBr(m_builder, condition, taken, notTaken); }
</del><ins>+ void branch(LValue condition, LBasicBlock taken, Weight takenWeight, LBasicBlock notTaken, Weight notTakenWeight);
+ void branch(LValue condition, WeightedTarget taken, WeightedTarget notTaken)
+ {
+ branch(condition, taken.target(), taken.weight(), notTaken.target(), notTaken.weight());
+ }
+
</ins><span class="cx"> template<typename VectorType>
</span><del>- void switchInstruction(LValue value, const VectorType& cases, LBasicBlock fallThrough) { buildSwitch(m_builder, value, cases, fallThrough); }
</del><ins>+ void switchInstruction(LValue value, const VectorType& cases, LBasicBlock fallThrough, Weight fallThroughWeight)
+ {
+ LValue inst = buildSwitch(m_builder, value, cases, fallThrough);
+
+ double total = 0;
+ if (!fallThroughWeight)
+ return;
+ total += fallThroughWeight.value();
+ for (unsigned i = cases.size(); i--;) {
+ if (!cases[i].weight())
+ return;
+ total += cases[i].weight().value();
+ }
+
+ Vector<LValue> mdArgs;
+ mdArgs.append(branchWeights);
+ mdArgs.append(constInt32(fallThroughWeight.scaleToTotal(total)));
+ for (unsigned i = 0; i < cases.size(); ++i)
+ mdArgs.append(constInt32(cases[i].weight().scaleToTotal(total)));
+
+ setMetadata(inst, profKind, mdNode(m_context, mdArgs));
+ }
+
</ins><span class="cx"> void ret(LValue value) { buildRet(m_builder, value); }
</span><span class="cx">
</span><span class="cx"> void unreachable() { buildUnreachable(m_builder); }
</span><span class="lines">@@ -424,10 +394,8 @@
</span><span class="cx"> call(trapIntrinsic());
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void crashNonTerminal()
- {
- call(intToPtr(constIntPtr(abort), pointerType(functionType(voidType))));
- }
</del><ins>+ void crashNonTerminal();
+
</ins><span class="cx"> void crash()
</span><span class="cx"> {
</span><span class="cx"> crashNonTerminal();
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLSwitchCaseh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLSwitchCase.h (164388 => 164389)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLSwitchCase.h 2014-02-19 21:57:41 UTC (rev 164388)
+++ trunk/Source/JavaScriptCore/ftl/FTLSwitchCase.h 2014-02-19 22:29:43 UTC (rev 164389)
</span><span class="lines">@@ -31,23 +31,27 @@
</span><span class="cx"> #if ENABLE(FTL_JIT)
</span><span class="cx">
</span><span class="cx"> #include "FTLAbbreviatedTypes.h"
</span><ins>+#include "FTLWeight.h"
</ins><span class="cx">
</span><span class="cx"> namespace JSC { namespace FTL {
</span><span class="cx">
</span><span class="cx"> class SwitchCase {
</span><span class="cx"> public:
</span><del>- SwitchCase(LValue value, LBasicBlock target)
</del><ins>+ SwitchCase(LValue value, LBasicBlock target, Weight weight)
</ins><span class="cx"> : m_value(value)
</span><span class="cx"> , m_target(target)
</span><ins>+ , m_weight(weight)
</ins><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> LValue value() const { return m_value; }
</span><span class="cx"> LBasicBlock target() const { return m_target; }
</span><ins>+ Weight weight() const { return m_weight; }
</ins><span class="cx">
</span><span class="cx"> private:
</span><span class="cx"> LValue m_value;
</span><span class="cx"> LBasicBlock m_target;
</span><ins>+ Weight m_weight;
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> } } // namespace JSC::FTL
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLWeighth"></a>
<div class="addfile"><h4>Added: trunk/Source/JavaScriptCore/ftl/FTLWeight.h (0 => 164389)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLWeight.h (rev 0)
+++ trunk/Source/JavaScriptCore/ftl/FTLWeight.h 2014-02-19 22:29:43 UTC (rev 164389)
</span><span class="lines">@@ -0,0 +1,75 @@
</span><ins>+/*
+ * Copyright (C) 2014 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef FTLWeight_h
+#define FTLWeight_h
+
+#if ENABLE(FTL_JIT)
+
+#include <wtf/MathExtras.h>
+#include <wtf/StdLibExtras.h>
+
+namespace JSC { namespace FTL {
+
+class Weight {
+public:
+ Weight()
+ : m_value(std::numeric_limits<float>::quiet_NaN())
+ {
+ }
+
+ explicit Weight(float value)
+ : m_value(value)
+ {
+ }
+
+ bool isSet() const { return m_value == m_value; }
+ bool operator!() const { return !isSet(); }
+
+ float value() const { return m_value; }
+
+ unsigned scaleToTotal(double total) const
+ {
+ // LLVM accepts branch 32-bit unsigned branch weights but in dumps it might
+ // display them as signed values. We don't need all 32 bits, so we just use the
+ // 31 bits.
+ double result = static_cast<double>(m_value) * INT_MAX / total;
+ if (result < 0)
+ return 0;
+ if (result > INT_MAX)
+ return INT_MAX;
+ return static_cast<unsigned>(result);
+ }
+
+private:
+ float m_value;
+};
+
+} } // namespace JSC::FTL
+
+#endif // ENABLE(FTL_JIT)
+
+#endif // FTLWeight_h
+
</ins></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLWeightedTargeth"></a>
<div class="addfile"><h4>Added: trunk/Source/JavaScriptCore/ftl/FTLWeightedTarget.h (0 => 164389)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLWeightedTarget.h (rev 0)
+++ trunk/Source/JavaScriptCore/ftl/FTLWeightedTarget.h 2014-02-19 22:29:43 UTC (rev 164389)
</span><span class="lines">@@ -0,0 +1,89 @@
</span><ins>+/*
+ * Copyright (C) 2014 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef FTLWeightedTarget_h
+#define FTLWeightedTarget_h
+
+#if ENABLE(FTL_JIT)
+
+#include "FTLAbbreviatedTypes.h"
+#include "FTLWeight.h"
+
+namespace JSC { namespace FTL {
+
+class WeightedTarget {
+public:
+ WeightedTarget()
+ : m_target(nullptr)
+ {
+ }
+
+ WeightedTarget(LBasicBlock target, Weight weight)
+ : m_target(target)
+ , m_weight(weight)
+ {
+ }
+
+ WeightedTarget(LBasicBlock target, float weight)
+ : m_target(target)
+ , m_weight(weight)
+ {
+ }
+
+ LBasicBlock target() const { return m_target; }
+ Weight weight() const { return m_weight; }
+
+private:
+ LBasicBlock m_target;
+ Weight m_weight;
+};
+
+// Helpers for creating weighted targets for statically known (or unknown) branch
+// profiles.
+
+inline WeightedTarget usually(LBasicBlock block)
+{
+ return WeightedTarget(block, 1);
+}
+
+inline WeightedTarget rarely(LBasicBlock block)
+{
+ return WeightedTarget(block, 0);
+}
+
+// This means we let LLVM figure it out basic on its static estimates. LLVM's static
+// estimates are usually pretty darn good, so there's generally nothing wrong with
+// using this.
+inline WeightedTarget unsure(LBasicBlock block)
+{
+ return WeightedTarget(block, Weight());
+}
+
+} } // namespace JSC::FTL
+
+#endif // ENABLE(FTL_JIT)
+
+#endif // FTLWeightedTarget_h
+
</ins></span></pre>
</div>
</div>
</body>
</html>