<!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>[197649] 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/197649">197649</a></dd>
<dt>Author</dt> <dd>fpizlo@apple.com</dd>
<dt>Date</dt> <dd>2016-03-06 18:07:28 -0800 (Sun, 06 Mar 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>DFG should know how to speculate StringOrOther
https://bugs.webkit.org/show_bug.cgi?id=155094
Reviewed by Saam Barati.
Any code that processes the regexp matches array was previously doing a relatively expensive
Branch(Untyped:). This introduces a new use kind called StringOrOther, which is perfect for
code that loops over the matches array and branches on the entries being non-empty.
To do this, I needed to introduce code into the FTL that creates new blocks. We still had that
awful FTL_NEW_BLOCK idiom since the only way to debug LLVM IR was to ascribe names to basic
blocks. B3 IR is inherently more debuggable since unlike LLVM, B3 knows how to always respect
code origin, and it knows how to print the code origin nicely in the dumps. So, rather than
continue using FTL_NEW_BLOCK(m_out, ("things")), I replaced all of that stuff with
m_out.newBlock(). It's much nicer that way.
This is a tiny speed-up on Octane/regexp at best. I was hoping for more. Oh well.
* bytecode/SpeculatedType.h:
(JSC::isStringSpeculation):
(JSC::isStringOrOtherSpeculation):
(JSC::isSymbolSpeculation):
* dfg/DFGFixupPhase.cpp:
(JSC::DFG::FixupPhase::fixupNode):
* dfg/DFGNode.h:
(JSC::DFG::Node::shouldSpeculateString):
(JSC::DFG::Node::shouldSpeculateStringOrOther):
(JSC::DFG::Node::shouldSpeculateStringObject):
* dfg/DFGSafeToExecute.h:
(JSC::DFG::SafeToExecuteEdge::operator()):
* dfg/DFGSpeculativeJIT.cpp:
(JSC::DFG::SpeculativeJIT::compileStringZeroLength):
(JSC::DFG::SpeculativeJIT::compileLogicalNotStringOrOther):
(JSC::DFG::SpeculativeJIT::emitStringBranch):
(JSC::DFG::SpeculativeJIT::emitStringOrOtherBranch):
(JSC::DFG::SpeculativeJIT::compileConstantStoragePointer):
(JSC::DFG::SpeculativeJIT::speculateObjectOrOther):
(JSC::DFG::SpeculativeJIT::speculateString):
(JSC::DFG::SpeculativeJIT::speculateStringOrOther):
(JSC::DFG::SpeculativeJIT::speculateStringIdentAndLoadStorage):
(JSC::DFG::SpeculativeJIT::speculate):
* dfg/DFGSpeculativeJIT.h:
* dfg/DFGSpeculativeJIT32_64.cpp:
(JSC::DFG::SpeculativeJIT::compileLogicalNot):
(JSC::DFG::SpeculativeJIT::emitBranch):
* dfg/DFGSpeculativeJIT64.cpp:
(JSC::DFG::SpeculativeJIT::compileLogicalNot):
(JSC::DFG::SpeculativeJIT::emitBranch):
* dfg/DFGUseKind.cpp:
(WTF::printInternal):
* dfg/DFGUseKind.h:
(JSC::DFG::typeFilterFor):
* ftl/FTLCapabilities.cpp:
(JSC::FTL::canCompile):
* ftl/FTLLowerDFGToB3.cpp:
(JSC::FTL::DFG::LowerDFGToB3::lower):
(JSC::FTL::DFG::LowerDFGToB3::compileDoubleRep):
(JSC::FTL::DFG::LowerDFGToB3::compileBooleanToNumber):
(JSC::FTL::DFG::LowerDFGToB3::compileToThis):
(JSC::FTL::DFG::LowerDFGToB3::compileArithMul):
(JSC::FTL::DFG::LowerDFGToB3::compileArithDiv):
(JSC::FTL::DFG::LowerDFGToB3::compileArithMod):
(JSC::FTL::DFG::LowerDFGToB3::compileArithMinOrMax):
(JSC::FTL::DFG::LowerDFGToB3::compileArithPow):
(JSC::FTL::DFG::LowerDFGToB3::compileArithRound):
(JSC::FTL::DFG::LowerDFGToB3::compileCheckStructure):
(JSC::FTL::DFG::LowerDFGToB3::compileArrayifyToStructure):
(JSC::FTL::DFG::LowerDFGToB3::compileGetById):
(JSC::FTL::DFG::LowerDFGToB3::compileGetIndexedPropertyStorage):
(JSC::FTL::DFG::LowerDFGToB3::compileGetTypedArrayByteOffset):
(JSC::FTL::DFG::LowerDFGToB3::compileGetByVal):
(JSC::FTL::DFG::LowerDFGToB3::compilePutByVal):
(JSC::FTL::DFG::LowerDFGToB3::compileArrayPush):
(JSC::FTL::DFG::LowerDFGToB3::compileArrayPop):
(JSC::FTL::DFG::LowerDFGToB3::compileCreateActivation):
(JSC::FTL::DFG::LowerDFGToB3::compileNewFunction):
(JSC::FTL::DFG::LowerDFGToB3::compileCreateDirectArguments):
(JSC::FTL::DFG::LowerDFGToB3::compileCopyRest):
(JSC::FTL::DFG::LowerDFGToB3::compileGetRestLength):
(JSC::FTL::DFG::LowerDFGToB3::compileNewArrayWithSize):
(JSC::FTL::DFG::LowerDFGToB3::compileNewTypedArray):
(JSC::FTL::DFG::LowerDFGToB3::compileToStringOrCallStringConstructor):
(JSC::FTL::DFG::LowerDFGToB3::compileToPrimitive):
(JSC::FTL::DFG::LowerDFGToB3::compileMakeRope):
(JSC::FTL::DFG::LowerDFGToB3::compileStringCharAt):
(JSC::FTL::DFG::LowerDFGToB3::compileStringCharCodeAt):
(JSC::FTL::DFG::LowerDFGToB3::compileStringFromCharCode):
(JSC::FTL::DFG::LowerDFGToB3::compileMultiGetByOffset):
(JSC::FTL::DFG::LowerDFGToB3::compileMultiPutByOffset):
(JSC::FTL::DFG::LowerDFGToB3::compileNotifyWrite):
(JSC::FTL::DFG::LowerDFGToB3::compileCompareStrictEq):
(JSC::FTL::DFG::LowerDFGToB3::compileForwardVarargs):
(JSC::FTL::DFG::LowerDFGToB3::compileSwitch):
(JSC::FTL::DFG::LowerDFGToB3::compileIsString):
(JSC::FTL::DFG::LowerDFGToB3::compileIsObject):
(JSC::FTL::DFG::LowerDFGToB3::compileIsObjectOrNull):
(JSC::FTL::DFG::LowerDFGToB3::compileIsFunction):
(JSC::FTL::DFG::LowerDFGToB3::compileTypeOf):
(JSC::FTL::DFG::LowerDFGToB3::compileOverridesHasInstance):
(JSC::FTL::DFG::LowerDFGToB3::compileInstanceOf):
(JSC::FTL::DFG::LowerDFGToB3::compileHasIndexedProperty):
(JSC::FTL::DFG::LowerDFGToB3::compileHasStructureProperty):
(JSC::FTL::DFG::LowerDFGToB3::compileGetDirectPname):
(JSC::FTL::DFG::LowerDFGToB3::compileGetEnumeratorStructurePname):
(JSC::FTL::DFG::LowerDFGToB3::compileGetEnumeratorGenericPname):
(JSC::FTL::DFG::LowerDFGToB3::compileMaterializeNewObject):
(JSC::FTL::DFG::LowerDFGToB3::compileMaterializeCreateActivation):
(JSC::FTL::DFG::LowerDFGToB3::compileCheckWatchdogTimer):
(JSC::FTL::DFG::LowerDFGToB3::checkStructure):
(JSC::FTL::DFG::LowerDFGToB3::numberOrNotCellToInt32):
(JSC::FTL::DFG::LowerDFGToB3::checkInferredType):
(JSC::FTL::DFG::LowerDFGToB3::allocatePropertyStorageWithSizeImpl):
(JSC::FTL::DFG::LowerDFGToB3::loadVectorWithBarrier):
(JSC::FTL::DFG::LowerDFGToB3::copyBarrier):
(JSC::FTL::DFG::LowerDFGToB3::loadVectorReadOnly):
(JSC::FTL::DFG::LowerDFGToB3::compareEqObjectOrOtherToObject):
(JSC::FTL::DFG::LowerDFGToB3::nonSpeculativeCompare):
(JSC::FTL::DFG::LowerDFGToB3::stringsEqual):
(JSC::FTL::DFG::LowerDFGToB3::allocateCell):
(JSC::FTL::DFG::LowerDFGToB3::allocateVariableSizedObject):
(JSC::FTL::DFG::LowerDFGToB3::allocateBasicStorageAndGetEnd):
(JSC::FTL::DFG::LowerDFGToB3::allocateObject):
(JSC::FTL::DFG::LowerDFGToB3::allocateJSArray):
(JSC::FTL::DFG::LowerDFGToB3::boolify):
(JSC::FTL::DFG::LowerDFGToB3::equalNullOrUndefined):
(JSC::FTL::DFG::LowerDFGToB3::contiguousPutByValOutOfBounds):
(JSC::FTL::DFG::LowerDFGToB3::switchString):
(JSC::FTL::DFG::LowerDFGToB3::switchStringRecurse):
(JSC::FTL::DFG::LowerDFGToB3::buildTypeOf):
(JSC::FTL::DFG::LowerDFGToB3::doubleToInt32):
(JSC::FTL::DFG::LowerDFGToB3::sensibleDoubleToInt32):
(JSC::FTL::DFG::LowerDFGToB3::strictInt52ToJSValue):
(JSC::FTL::DFG::LowerDFGToB3::jsValueToStrictInt52):
(JSC::FTL::DFG::LowerDFGToB3::convertDoubleToInt32):
(JSC::FTL::DFG::LowerDFGToB3::speculate):
(JSC::FTL::DFG::LowerDFGToB3::speculateCellOrOther):
(JSC::FTL::DFG::LowerDFGToB3::speculateObjectOrOther):
(JSC::FTL::DFG::LowerDFGToB3::speculateString):
(JSC::FTL::DFG::LowerDFGToB3::speculateStringOrOther):
(JSC::FTL::DFG::LowerDFGToB3::speculateStringIdent):
(JSC::FTL::DFG::LowerDFGToB3::speculateStringOrStringObject):
(JSC::FTL::DFG::LowerDFGToB3::speculateRealNumber):
(JSC::FTL::DFG::LowerDFGToB3::speculateNotStringVar):
(JSC::FTL::DFG::LowerDFGToB3::emitStoreBarrier):
(JSC::FTL::DFG::LowerDFGToB3::callCheck):
* ftl/FTLOutput.cpp:
(JSC::FTL::Output::initialize):
(JSC::FTL::Output::newBlock):
(JSC::FTL::Output::check):
* ftl/FTLOutput.h:
(JSC::FTL::Output::setFrequency):
(JSC::FTL::Output::insertNewBlocksBefore):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCorebytecodeSpeculatedTypeh">trunk/Source/JavaScriptCore/bytecode/SpeculatedType.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGFixupPhasecpp">trunk/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGNodeh">trunk/Source/JavaScriptCore/dfg/DFGNode.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGSafeToExecuteh">trunk/Source/JavaScriptCore/dfg/DFGSafeToExecute.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGSpeculativeJITcpp">trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGSpeculativeJITh">trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGSpeculativeJIT32_64cpp">trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGSpeculativeJIT64cpp">trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGUseKindcpp">trunk/Source/JavaScriptCore/dfg/DFGUseKind.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGUseKindh">trunk/Source/JavaScriptCore/dfg/DFGUseKind.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLCapabilitiescpp">trunk/Source/JavaScriptCore/ftl/FTLCapabilities.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreftlFTLLowerDFGToB3cpp">trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.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>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (197648 => 197649)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2016-03-07 01:00:33 UTC (rev 197648)
+++ trunk/Source/JavaScriptCore/ChangeLog 2016-03-07 02:07:28 UTC (rev 197649)
</span><span class="lines">@@ -1,3 +1,158 @@
</span><ins>+2016-03-06 Filip Pizlo <fpizlo@apple.com>
+
+ DFG should know how to speculate StringOrOther
+ https://bugs.webkit.org/show_bug.cgi?id=155094
+
+ Reviewed by Saam Barati.
+
+ Any code that processes the regexp matches array was previously doing a relatively expensive
+ Branch(Untyped:). This introduces a new use kind called StringOrOther, which is perfect for
+ code that loops over the matches array and branches on the entries being non-empty.
+
+ To do this, I needed to introduce code into the FTL that creates new blocks. We still had that
+ awful FTL_NEW_BLOCK idiom since the only way to debug LLVM IR was to ascribe names to basic
+ blocks. B3 IR is inherently more debuggable since unlike LLVM, B3 knows how to always respect
+ code origin, and it knows how to print the code origin nicely in the dumps. So, rather than
+ continue using FTL_NEW_BLOCK(m_out, ("things")), I replaced all of that stuff with
+ m_out.newBlock(). It's much nicer that way.
+
+ This is a tiny speed-up on Octane/regexp at best. I was hoping for more. Oh well.
+
+ * bytecode/SpeculatedType.h:
+ (JSC::isStringSpeculation):
+ (JSC::isStringOrOtherSpeculation):
+ (JSC::isSymbolSpeculation):
+ * dfg/DFGFixupPhase.cpp:
+ (JSC::DFG::FixupPhase::fixupNode):
+ * dfg/DFGNode.h:
+ (JSC::DFG::Node::shouldSpeculateString):
+ (JSC::DFG::Node::shouldSpeculateStringOrOther):
+ (JSC::DFG::Node::shouldSpeculateStringObject):
+ * dfg/DFGSafeToExecute.h:
+ (JSC::DFG::SafeToExecuteEdge::operator()):
+ * dfg/DFGSpeculativeJIT.cpp:
+ (JSC::DFG::SpeculativeJIT::compileStringZeroLength):
+ (JSC::DFG::SpeculativeJIT::compileLogicalNotStringOrOther):
+ (JSC::DFG::SpeculativeJIT::emitStringBranch):
+ (JSC::DFG::SpeculativeJIT::emitStringOrOtherBranch):
+ (JSC::DFG::SpeculativeJIT::compileConstantStoragePointer):
+ (JSC::DFG::SpeculativeJIT::speculateObjectOrOther):
+ (JSC::DFG::SpeculativeJIT::speculateString):
+ (JSC::DFG::SpeculativeJIT::speculateStringOrOther):
+ (JSC::DFG::SpeculativeJIT::speculateStringIdentAndLoadStorage):
+ (JSC::DFG::SpeculativeJIT::speculate):
+ * dfg/DFGSpeculativeJIT.h:
+ * dfg/DFGSpeculativeJIT32_64.cpp:
+ (JSC::DFG::SpeculativeJIT::compileLogicalNot):
+ (JSC::DFG::SpeculativeJIT::emitBranch):
+ * dfg/DFGSpeculativeJIT64.cpp:
+ (JSC::DFG::SpeculativeJIT::compileLogicalNot):
+ (JSC::DFG::SpeculativeJIT::emitBranch):
+ * dfg/DFGUseKind.cpp:
+ (WTF::printInternal):
+ * dfg/DFGUseKind.h:
+ (JSC::DFG::typeFilterFor):
+ * ftl/FTLCapabilities.cpp:
+ (JSC::FTL::canCompile):
+ * ftl/FTLLowerDFGToB3.cpp:
+ (JSC::FTL::DFG::LowerDFGToB3::lower):
+ (JSC::FTL::DFG::LowerDFGToB3::compileDoubleRep):
+ (JSC::FTL::DFG::LowerDFGToB3::compileBooleanToNumber):
+ (JSC::FTL::DFG::LowerDFGToB3::compileToThis):
+ (JSC::FTL::DFG::LowerDFGToB3::compileArithMul):
+ (JSC::FTL::DFG::LowerDFGToB3::compileArithDiv):
+ (JSC::FTL::DFG::LowerDFGToB3::compileArithMod):
+ (JSC::FTL::DFG::LowerDFGToB3::compileArithMinOrMax):
+ (JSC::FTL::DFG::LowerDFGToB3::compileArithPow):
+ (JSC::FTL::DFG::LowerDFGToB3::compileArithRound):
+ (JSC::FTL::DFG::LowerDFGToB3::compileCheckStructure):
+ (JSC::FTL::DFG::LowerDFGToB3::compileArrayifyToStructure):
+ (JSC::FTL::DFG::LowerDFGToB3::compileGetById):
+ (JSC::FTL::DFG::LowerDFGToB3::compileGetIndexedPropertyStorage):
+ (JSC::FTL::DFG::LowerDFGToB3::compileGetTypedArrayByteOffset):
+ (JSC::FTL::DFG::LowerDFGToB3::compileGetByVal):
+ (JSC::FTL::DFG::LowerDFGToB3::compilePutByVal):
+ (JSC::FTL::DFG::LowerDFGToB3::compileArrayPush):
+ (JSC::FTL::DFG::LowerDFGToB3::compileArrayPop):
+ (JSC::FTL::DFG::LowerDFGToB3::compileCreateActivation):
+ (JSC::FTL::DFG::LowerDFGToB3::compileNewFunction):
+ (JSC::FTL::DFG::LowerDFGToB3::compileCreateDirectArguments):
+ (JSC::FTL::DFG::LowerDFGToB3::compileCopyRest):
+ (JSC::FTL::DFG::LowerDFGToB3::compileGetRestLength):
+ (JSC::FTL::DFG::LowerDFGToB3::compileNewArrayWithSize):
+ (JSC::FTL::DFG::LowerDFGToB3::compileNewTypedArray):
+ (JSC::FTL::DFG::LowerDFGToB3::compileToStringOrCallStringConstructor):
+ (JSC::FTL::DFG::LowerDFGToB3::compileToPrimitive):
+ (JSC::FTL::DFG::LowerDFGToB3::compileMakeRope):
+ (JSC::FTL::DFG::LowerDFGToB3::compileStringCharAt):
+ (JSC::FTL::DFG::LowerDFGToB3::compileStringCharCodeAt):
+ (JSC::FTL::DFG::LowerDFGToB3::compileStringFromCharCode):
+ (JSC::FTL::DFG::LowerDFGToB3::compileMultiGetByOffset):
+ (JSC::FTL::DFG::LowerDFGToB3::compileMultiPutByOffset):
+ (JSC::FTL::DFG::LowerDFGToB3::compileNotifyWrite):
+ (JSC::FTL::DFG::LowerDFGToB3::compileCompareStrictEq):
+ (JSC::FTL::DFG::LowerDFGToB3::compileForwardVarargs):
+ (JSC::FTL::DFG::LowerDFGToB3::compileSwitch):
+ (JSC::FTL::DFG::LowerDFGToB3::compileIsString):
+ (JSC::FTL::DFG::LowerDFGToB3::compileIsObject):
+ (JSC::FTL::DFG::LowerDFGToB3::compileIsObjectOrNull):
+ (JSC::FTL::DFG::LowerDFGToB3::compileIsFunction):
+ (JSC::FTL::DFG::LowerDFGToB3::compileTypeOf):
+ (JSC::FTL::DFG::LowerDFGToB3::compileOverridesHasInstance):
+ (JSC::FTL::DFG::LowerDFGToB3::compileInstanceOf):
+ (JSC::FTL::DFG::LowerDFGToB3::compileHasIndexedProperty):
+ (JSC::FTL::DFG::LowerDFGToB3::compileHasStructureProperty):
+ (JSC::FTL::DFG::LowerDFGToB3::compileGetDirectPname):
+ (JSC::FTL::DFG::LowerDFGToB3::compileGetEnumeratorStructurePname):
+ (JSC::FTL::DFG::LowerDFGToB3::compileGetEnumeratorGenericPname):
+ (JSC::FTL::DFG::LowerDFGToB3::compileMaterializeNewObject):
+ (JSC::FTL::DFG::LowerDFGToB3::compileMaterializeCreateActivation):
+ (JSC::FTL::DFG::LowerDFGToB3::compileCheckWatchdogTimer):
+ (JSC::FTL::DFG::LowerDFGToB3::checkStructure):
+ (JSC::FTL::DFG::LowerDFGToB3::numberOrNotCellToInt32):
+ (JSC::FTL::DFG::LowerDFGToB3::checkInferredType):
+ (JSC::FTL::DFG::LowerDFGToB3::allocatePropertyStorageWithSizeImpl):
+ (JSC::FTL::DFG::LowerDFGToB3::loadVectorWithBarrier):
+ (JSC::FTL::DFG::LowerDFGToB3::copyBarrier):
+ (JSC::FTL::DFG::LowerDFGToB3::loadVectorReadOnly):
+ (JSC::FTL::DFG::LowerDFGToB3::compareEqObjectOrOtherToObject):
+ (JSC::FTL::DFG::LowerDFGToB3::nonSpeculativeCompare):
+ (JSC::FTL::DFG::LowerDFGToB3::stringsEqual):
+ (JSC::FTL::DFG::LowerDFGToB3::allocateCell):
+ (JSC::FTL::DFG::LowerDFGToB3::allocateVariableSizedObject):
+ (JSC::FTL::DFG::LowerDFGToB3::allocateBasicStorageAndGetEnd):
+ (JSC::FTL::DFG::LowerDFGToB3::allocateObject):
+ (JSC::FTL::DFG::LowerDFGToB3::allocateJSArray):
+ (JSC::FTL::DFG::LowerDFGToB3::boolify):
+ (JSC::FTL::DFG::LowerDFGToB3::equalNullOrUndefined):
+ (JSC::FTL::DFG::LowerDFGToB3::contiguousPutByValOutOfBounds):
+ (JSC::FTL::DFG::LowerDFGToB3::switchString):
+ (JSC::FTL::DFG::LowerDFGToB3::switchStringRecurse):
+ (JSC::FTL::DFG::LowerDFGToB3::buildTypeOf):
+ (JSC::FTL::DFG::LowerDFGToB3::doubleToInt32):
+ (JSC::FTL::DFG::LowerDFGToB3::sensibleDoubleToInt32):
+ (JSC::FTL::DFG::LowerDFGToB3::strictInt52ToJSValue):
+ (JSC::FTL::DFG::LowerDFGToB3::jsValueToStrictInt52):
+ (JSC::FTL::DFG::LowerDFGToB3::convertDoubleToInt32):
+ (JSC::FTL::DFG::LowerDFGToB3::speculate):
+ (JSC::FTL::DFG::LowerDFGToB3::speculateCellOrOther):
+ (JSC::FTL::DFG::LowerDFGToB3::speculateObjectOrOther):
+ (JSC::FTL::DFG::LowerDFGToB3::speculateString):
+ (JSC::FTL::DFG::LowerDFGToB3::speculateStringOrOther):
+ (JSC::FTL::DFG::LowerDFGToB3::speculateStringIdent):
+ (JSC::FTL::DFG::LowerDFGToB3::speculateStringOrStringObject):
+ (JSC::FTL::DFG::LowerDFGToB3::speculateRealNumber):
+ (JSC::FTL::DFG::LowerDFGToB3::speculateNotStringVar):
+ (JSC::FTL::DFG::LowerDFGToB3::emitStoreBarrier):
+ (JSC::FTL::DFG::LowerDFGToB3::callCheck):
+ * ftl/FTLOutput.cpp:
+ (JSC::FTL::Output::initialize):
+ (JSC::FTL::Output::newBlock):
+ (JSC::FTL::Output::check):
+ * ftl/FTLOutput.h:
+ (JSC::FTL::Output::setFrequency):
+ (JSC::FTL::Output::insertNewBlocksBefore):
+
</ins><span class="cx"> 2016-03-06 Saam Barati <sbarati@apple.com>
</span><span class="cx">
</span><span class="cx"> [[GetPrototypeOf]] should be a fully virtual method in the method table
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorebytecodeSpeculatedTypeh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/bytecode/SpeculatedType.h (197648 => 197649)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/bytecode/SpeculatedType.h 2016-03-07 01:00:33 UTC (rev 197648)
+++ trunk/Source/JavaScriptCore/bytecode/SpeculatedType.h 2016-03-07 02:07:28 UTC (rev 197649)
</span><span class="lines">@@ -149,6 +149,11 @@
</span><span class="cx"> return !!value && (value & SpecString) == value;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+inline bool isStringOrOtherSpeculation(SpeculatedType value)
+{
+ return !!value && (value & (SpecString | SpecOther)) == value;
+}
+
</ins><span class="cx"> inline bool isSymbolSpeculation(SpeculatedType value)
</span><span class="cx"> {
</span><span class="cx"> return value == SpecSymbol;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGFixupPhasecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp (197648 => 197649)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp 2016-03-07 01:00:33 UTC (rev 197648)
+++ trunk/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp 2016-03-07 02:07:28 UTC (rev 197649)
</span><span class="lines">@@ -418,6 +418,8 @@
</span><span class="cx"> fixEdge<DoubleRepUse>(node->child1());
</span><span class="cx"> else if (node->child1()->shouldSpeculateString())
</span><span class="cx"> fixEdge<StringUse>(node->child1());
</span><ins>+ else if (node->child1()->shouldSpeculateStringOrOther())
+ fixEdge<StringOrOtherUse>(node->child1());
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -923,6 +925,8 @@
</span><span class="cx"> fixEdge<DoubleRepUse>(node->child1());
</span><span class="cx"> else if (node->child1()->shouldSpeculateString())
</span><span class="cx"> fixEdge<StringUse>(node->child1());
</span><ins>+ else if (node->child1()->shouldSpeculateStringOrOther())
+ fixEdge<StringOrOtherUse>(node->child1());
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGNodeh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGNode.h (197648 => 197649)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGNode.h 2016-03-07 01:00:33 UTC (rev 197648)
+++ trunk/Source/JavaScriptCore/dfg/DFGNode.h 2016-03-07 02:07:28 UTC (rev 197649)
</span><span class="lines">@@ -1957,6 +1957,11 @@
</span><span class="cx"> return isStringSpeculation(prediction());
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ bool shouldSpeculateStringOrOther()
+ {
+ return isStringOrOtherSpeculation(prediction());
+ }
+
</ins><span class="cx"> bool shouldSpeculateStringObject()
</span><span class="cx"> {
</span><span class="cx"> return isStringObjectSpeculation(prediction());
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGSafeToExecuteh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGSafeToExecute.h (197648 => 197649)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGSafeToExecute.h 2016-03-07 01:00:33 UTC (rev 197648)
+++ trunk/Source/JavaScriptCore/dfg/DFGSafeToExecute.h 2016-03-07 02:07:28 UTC (rev 197649)
</span><span class="lines">@@ -61,6 +61,7 @@
</span><span class="cx"> case ObjectOrOtherUse:
</span><span class="cx"> case StringIdentUse:
</span><span class="cx"> case StringUse:
</span><ins>+ case StringOrOtherUse:
</ins><span class="cx"> case SymbolUse:
</span><span class="cx"> case StringObjectUse:
</span><span class="cx"> case StringOrStringObjectUse:
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGSpeculativeJITcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp (197648 => 197649)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp 2016-03-07 01:00:33 UTC (rev 197648)
+++ trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp 2016-03-07 02:07:28 UTC (rev 197649)
</span><span class="lines">@@ -5130,6 +5130,30 @@
</span><span class="cx"> unblessedBooleanResult(eqGPR, node);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+void SpeculativeJIT::compileLogicalNotStringOrOther(Node* node)
+{
+ JSValueOperand value(this, node->child1(), ManualOperandSpeculation);
+ GPRTemporary temp(this);
+ JSValueRegs valueRegs = value.jsValueRegs();
+ GPRReg tempGPR = temp.gpr();
+
+ JITCompiler::Jump notCell = m_jit.branchIfNotCell(valueRegs);
+ GPRReg cellGPR = valueRegs.payloadGPR();
+ DFG_TYPE_CHECK(
+ valueRegs, node->child1(), (~SpecCell) | SpecString, m_jit.branchIfNotString(cellGPR));
+ m_jit.test32(
+ JITCompiler::Zero, JITCompiler::Address(cellGPR, JSString::offsetOfLength()),
+ JITCompiler::TrustedImm32(-1), tempGPR);
+ JITCompiler::Jump done = m_jit.jump();
+ notCell.link(&m_jit);
+ DFG_TYPE_CHECK(
+ valueRegs, node->child1(), SpecCell | SpecOther, m_jit.branchIfNotOther(valueRegs, tempGPR));
+ m_jit.move(TrustedImm32(1), tempGPR);
+ done.link(&m_jit);
+
+ unblessedBooleanResult(tempGPR, node);
+}
+
</ins><span class="cx"> void SpeculativeJIT::emitStringBranch(Edge nodeUse, BasicBlock* taken, BasicBlock* notTaken)
</span><span class="cx"> {
</span><span class="cx"> SpeculateCellOperand str(this, nodeUse);
</span><span class="lines">@@ -5139,6 +5163,27 @@
</span><span class="cx"> noResult(m_currentNode);
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+void SpeculativeJIT::emitStringOrOtherBranch(Edge nodeUse, BasicBlock* taken, BasicBlock* notTaken)
+{
+ JSValueOperand value(this, nodeUse, ManualOperandSpeculation);
+ GPRTemporary temp(this);
+ JSValueRegs valueRegs = value.jsValueRegs();
+ GPRReg tempGPR = temp.gpr();
+
+ JITCompiler::Jump notCell = m_jit.branchIfNotCell(valueRegs);
+ GPRReg cellGPR = valueRegs.payloadGPR();
+ DFG_TYPE_CHECK(valueRegs, nodeUse, (~SpecCell) | SpecString, m_jit.branchIfNotString(cellGPR));
+ branchTest32(
+ JITCompiler::Zero, JITCompiler::Address(cellGPR, JSString::offsetOfLength()),
+ JITCompiler::TrustedImm32(-1), notTaken);
+ jump(taken, ForceJump);
+ notCell.link(&m_jit);
+ DFG_TYPE_CHECK(
+ valueRegs, nodeUse, SpecCell | SpecOther, m_jit.branchIfNotOther(valueRegs, tempGPR));
+ jump(notTaken);
+ noResult(m_currentNode);
+}
+
</ins><span class="cx"> void SpeculativeJIT::compileConstantStoragePointer(Node* node)
</span><span class="cx"> {
</span><span class="cx"> GPRTemporary storage(this);
</span><span class="lines">@@ -6674,11 +6719,9 @@
</span><span class="cx"> operand.jsValueRegs(), edge, (~SpecCell) | SpecObject, m_jit.branchIfNotObject(gpr));
</span><span class="cx"> MacroAssembler::Jump done = m_jit.jump();
</span><span class="cx"> notCell.link(&m_jit);
</span><del>- if (needsTypeCheck(edge, SpecCell | SpecOther)) {
- typeCheck(
- operand.jsValueRegs(), edge, SpecCell | SpecOther,
- m_jit.branchIfNotOther(operand.jsValueRegs(), tempGPR));
- }
</del><ins>+ DFG_TYPE_CHECK(
+ operand.jsValueRegs(), edge, SpecCell | SpecOther,
+ m_jit.branchIfNotOther(operand.jsValueRegs(), tempGPR));
</ins><span class="cx"> done.link(&m_jit);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -6688,6 +6731,29 @@
</span><span class="cx"> JSValueSource::unboxedCell(cell), edge, SpecString | ~SpecCell, m_jit.branchIfNotString(cell));
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+void SpeculativeJIT::speculateStringOrOther(Edge edge, JSValueRegs regs, GPRReg scratch)
+{
+ JITCompiler::Jump notCell = m_jit.branchIfNotCell(regs);
+ GPRReg cell = regs.payloadGPR();
+ DFG_TYPE_CHECK(regs, edge, (~SpecCell) | SpecString, m_jit.branchIfNotString(cell));
+ JITCompiler::Jump done = m_jit.jump();
+ notCell.link(&m_jit);
+ DFG_TYPE_CHECK(regs, edge, SpecCell | SpecOther, m_jit.branchIfNotOther(regs, scratch));
+ done.link(&m_jit);
+}
+
+void SpeculativeJIT::speculateStringOrOther(Edge edge)
+{
+ if (!needsTypeCheck(edge, SpecString | SpecOther))
+ return;
+
+ JSValueOperand operand(this, edge, ManualOperandSpeculation);
+ GPRTemporary temp(this);
+ JSValueRegs regs = operand.jsValueRegs();
+ GPRReg tempGPR = temp.gpr();
+ speculateStringOrOther(edge, regs, tempGPR);
+}
+
</ins><span class="cx"> void SpeculativeJIT::speculateStringIdentAndLoadStorage(Edge edge, GPRReg string, GPRReg storage)
</span><span class="cx"> {
</span><span class="cx"> m_jit.loadPtr(MacroAssembler::Address(string, JSString::offsetOfValue()), storage);
</span><span class="lines">@@ -6935,6 +7001,9 @@
</span><span class="cx"> case StringUse:
</span><span class="cx"> speculateString(edge);
</span><span class="cx"> break;
</span><ins>+ case StringOrOtherUse:
+ speculateStringOrOther(edge);
+ break;
</ins><span class="cx"> case SymbolUse:
</span><span class="cx"> speculateSymbol(edge);
</span><span class="cx"> break;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGSpeculativeJITh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h (197648 => 197649)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h 2016-03-07 01:00:33 UTC (rev 197648)
+++ trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h 2016-03-07 02:07:28 UTC (rev 197649)
</span><span class="lines">@@ -2238,6 +2238,7 @@
</span><span class="cx"> void compileObjectToObjectOrOtherEquality(Edge leftChild, Edge rightChild);
</span><span class="cx"> void compileObjectOrOtherLogicalNot(Edge value);
</span><span class="cx"> void compileLogicalNot(Node*);
</span><ins>+ void compileLogicalNotStringOrOther(Node*);
</ins><span class="cx"> void compileStringEquality(
</span><span class="cx"> Node*, GPRReg leftGPR, GPRReg rightGPR, GPRReg lengthGPR,
</span><span class="cx"> GPRReg leftTempGPR, GPRReg rightTempGPR, GPRReg leftTemp2GPR,
</span><span class="lines">@@ -2257,6 +2258,7 @@
</span><span class="cx">
</span><span class="cx"> void emitObjectOrOtherBranch(Edge value, BasicBlock* taken, BasicBlock* notTaken);
</span><span class="cx"> void emitStringBranch(Edge value, BasicBlock* taken, BasicBlock* notTaken);
</span><ins>+ void emitStringOrOtherBranch(Edge value, BasicBlock* taken, BasicBlock* notTaken);
</ins><span class="cx"> void emitBranch(Node*);
</span><span class="cx">
</span><span class="cx"> struct StringSwitchCase {
</span><span class="lines">@@ -2573,6 +2575,8 @@
</span><span class="cx"> void speculateStringIdent(Edge edge, GPRReg string);
</span><span class="cx"> void speculateStringIdent(Edge);
</span><span class="cx"> void speculateString(Edge);
</span><ins>+ void speculateStringOrOther(Edge, JSValueRegs, GPRReg scratch);
+ void speculateStringOrOther(Edge);
</ins><span class="cx"> void speculateNotStringVar(Edge);
</span><span class="cx"> template<typename StructureLocationType>
</span><span class="cx"> void speculateStringObjectForStructure(Edge, StructureLocationType);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGSpeculativeJIT32_64cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp (197648 => 197649)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp 2016-03-07 01:00:33 UTC (rev 197648)
+++ trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp 2016-03-07 02:07:28 UTC (rev 197649)
</span><span class="lines">@@ -1629,6 +1629,9 @@
</span><span class="cx"> case StringUse:
</span><span class="cx"> return compileStringZeroLength(node);
</span><span class="cx">
</span><ins>+ case StringOrOtherUse:
+ return compileLogicalNotStringOrOther(node);
+
</ins><span class="cx"> default:
</span><span class="cx"> RELEASE_ASSERT_NOT_REACHED();
</span><span class="cx"> break;
</span><span class="lines">@@ -1719,6 +1722,11 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ case StringOrOtherUse: {
+ emitStringOrOtherBranch(node->child1(), taken, notTaken);
+ return;
+ }
+
</ins><span class="cx"> case DoubleRepUse:
</span><span class="cx"> case Int32Use: {
</span><span class="cx"> if (node->child1().useKind() == Int32Use) {
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGSpeculativeJIT64cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp (197648 => 197649)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp 2016-03-07 01:00:33 UTC (rev 197648)
+++ trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp 2016-03-07 02:07:28 UTC (rev 197649)
</span><span class="lines">@@ -1774,6 +1774,9 @@
</span><span class="cx"> case StringUse:
</span><span class="cx"> return compileStringZeroLength(node);
</span><span class="cx">
</span><ins>+ case StringOrOtherUse:
+ return compileLogicalNotStringOrOther(node);
+
</ins><span class="cx"> default:
</span><span class="cx"> DFG_CRASH(m_jit.graph(), node, "Bad use kind");
</span><span class="cx"> break;
</span><span class="lines">@@ -1875,6 +1878,11 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ case StringOrOtherUse: {
+ emitStringOrOtherBranch(node->child1(), taken, notTaken);
+ return;
+ }
+
</ins><span class="cx"> case UntypedUse:
</span><span class="cx"> case BooleanUse:
</span><span class="cx"> case KnownBooleanUse: {
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGUseKindcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGUseKind.cpp (197648 => 197649)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGUseKind.cpp 2016-03-07 01:00:33 UTC (rev 197648)
+++ trunk/Source/JavaScriptCore/dfg/DFGUseKind.cpp 2016-03-07 02:07:28 UTC (rev 197649)
</span><span class="lines">@@ -103,6 +103,9 @@
</span><span class="cx"> case StringUse:
</span><span class="cx"> out.print("String");
</span><span class="cx"> return;
</span><ins>+ case StringOrOtherUse:
+ out.print("StringOrOther");
+ return;
</ins><span class="cx"> case KnownStringUse:
</span><span class="cx"> out.print("KnownString");
</span><span class="cx"> return;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGUseKindh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGUseKind.h (197648 => 197649)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGUseKind.h 2016-03-07 01:00:33 UTC (rev 197648)
+++ trunk/Source/JavaScriptCore/dfg/DFGUseKind.h 2016-03-07 02:07:28 UTC (rev 197649)
</span><span class="lines">@@ -59,6 +59,7 @@
</span><span class="cx"> ObjectOrOtherUse,
</span><span class="cx"> StringIdentUse,
</span><span class="cx"> StringUse,
</span><ins>+ StringOrOtherUse,
</ins><span class="cx"> KnownStringUse,
</span><span class="cx"> KnownPrimitiveUse, // This bizarre type arises for op_strcat, which has a bytecode guarantee that it will only see primitives (i.e. not objects).
</span><span class="cx"> SymbolUse,
</span><span class="lines">@@ -127,6 +128,8 @@
</span><span class="cx"> case StringUse:
</span><span class="cx"> case KnownStringUse:
</span><span class="cx"> return SpecString;
</span><ins>+ case StringOrOtherUse:
+ return SpecString | SpecOther;
</ins><span class="cx"> case KnownPrimitiveUse:
</span><span class="cx"> return SpecHeapTop & ~SpecObject;
</span><span class="cx"> case SymbolUse:
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLCapabilitiescpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLCapabilities.cpp (197648 => 197649)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLCapabilities.cpp 2016-03-07 01:00:33 UTC (rev 197648)
+++ trunk/Source/JavaScriptCore/ftl/FTLCapabilities.cpp 2016-03-07 02:07:28 UTC (rev 197649)
</span><span class="lines">@@ -463,6 +463,7 @@
</span><span class="cx"> case FunctionUse:
</span><span class="cx"> case ObjectOrOtherUse:
</span><span class="cx"> case StringUse:
</span><ins>+ case StringOrOtherUse:
</ins><span class="cx"> case KnownStringUse:
</span><span class="cx"> case KnownPrimitiveUse:
</span><span class="cx"> case StringObjectUse:
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLLowerDFGToB3cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp (197648 => 197649)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp 2016-03-07 01:00:33 UTC (rev 197648)
+++ trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp 2016-03-07 02:07:28 UTC (rev 197649)
</span><span class="lines">@@ -154,18 +154,18 @@
</span><span class="cx"> // We use prologue frequency for all of the initialization code.
</span><span class="cx"> m_out.setFrequency(1);
</span><span class="cx">
</span><del>- m_prologue = FTL_NEW_BLOCK(m_out, ("Prologue"));
- LBasicBlock stackOverflow = FTL_NEW_BLOCK(m_out, ("Stack overflow"));
- m_handleExceptions = FTL_NEW_BLOCK(m_out, ("Handle Exceptions"));
</del><ins>+ m_prologue = m_out.newBlock();
+ LBasicBlock stackOverflow = m_out.newBlock();
+ m_handleExceptions = m_out.newBlock();
</ins><span class="cx">
</span><del>- LBasicBlock checkArguments = FTL_NEW_BLOCK(m_out, ("Check arguments"));
</del><ins>+ LBasicBlock checkArguments = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> for (BlockIndex blockIndex = 0; blockIndex < m_graph.numBlocks(); ++blockIndex) {
</span><span class="cx"> m_highBlock = m_graph.block(blockIndex);
</span><span class="cx"> if (!m_highBlock)
</span><span class="cx"> continue;
</span><span class="cx"> m_out.setFrequency(m_highBlock->executionCount);
</span><del>- m_blocks.add(m_highBlock, FTL_NEW_BLOCK(m_out, ("Block ", *m_highBlock)));
</del><ins>+ m_blocks.add(m_highBlock, m_out.newBlock());
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Back to prologue frequency for any bocks that get sneakily created in the initialization code.
</span><span class="lines">@@ -1052,8 +1052,8 @@
</span><span class="cx">
</span><span class="cx"> LValue doubleValue = unboxDouble(value);
</span><span class="cx">
</span><del>- LBasicBlock intCase = FTL_NEW_BLOCK(m_out, ("DoubleRep RealNumberUse int case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("DoubleRep continuation"));
</del><ins>+ LBasicBlock intCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> ValueFromBlock fastResult = m_out.anchor(doubleValue);
</span><span class="cx"> m_out.branch(
</span><span class="lines">@@ -1080,11 +1080,11 @@
</span><span class="cx">
</span><span class="cx"> LValue value = lowJSValue(m_node->child1(), ManualOperandSpeculation);
</span><span class="cx">
</span><del>- LBasicBlock intCase = FTL_NEW_BLOCK(m_out, ("jsValueToDouble unboxing int case"));
- LBasicBlock doubleTesting = FTL_NEW_BLOCK(m_out, ("jsValueToDouble testing double case"));
- LBasicBlock doubleCase = FTL_NEW_BLOCK(m_out, ("jsValueToDouble unboxing double case"));
- LBasicBlock nonDoubleCase = FTL_NEW_BLOCK(m_out, ("jsValueToDouble testing undefined case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("jsValueToDouble unboxing continuation"));
</del><ins>+ LBasicBlock intCase = m_out.newBlock();
+ LBasicBlock doubleTesting = m_out.newBlock();
+ LBasicBlock doubleCase = m_out.newBlock();
+ LBasicBlock nonDoubleCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> isNotInt32(value, provenType(m_node->child1())),
</span><span class="lines">@@ -1105,12 +1105,12 @@
</span><span class="cx"> m_out.jump(continuation);
</span><span class="cx">
</span><span class="cx"> if (shouldConvertNonNumber) {
</span><del>- LBasicBlock undefinedCase = FTL_NEW_BLOCK(m_out, ("jsValueToDouble converting undefined case"));
- LBasicBlock testNullCase = FTL_NEW_BLOCK(m_out, ("jsValueToDouble testing null case"));
- LBasicBlock nullCase = FTL_NEW_BLOCK(m_out, ("jsValueToDouble converting null case"));
- LBasicBlock testBooleanTrueCase = FTL_NEW_BLOCK(m_out, ("jsValueToDouble testing boolean true case"));
- LBasicBlock convertBooleanTrueCase = FTL_NEW_BLOCK(m_out, ("jsValueToDouble convert boolean true case"));
- LBasicBlock convertBooleanFalseCase = FTL_NEW_BLOCK(m_out, ("jsValueToDouble convert boolean false case"));
</del><ins>+ LBasicBlock undefinedCase = m_out.newBlock();
+ LBasicBlock testNullCase = m_out.newBlock();
+ LBasicBlock nullCase = m_out.newBlock();
+ LBasicBlock testBooleanTrueCase = m_out.newBlock();
+ LBasicBlock convertBooleanTrueCase = m_out.newBlock();
+ LBasicBlock convertBooleanFalseCase = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.appendTo(nonDoubleCase, undefinedCase);
</span><span class="cx"> LValue valueIsUndefined = m_out.equal(value, m_out.constInt64(ValueUndefined));
</span><span class="lines">@@ -1278,8 +1278,8 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- LBasicBlock booleanCase = FTL_NEW_BLOCK(m_out, ("BooleanToNumber boolean case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("BooleanToNumber continuation"));
</del><ins>+ LBasicBlock booleanCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> ValueFromBlock notBooleanResult = m_out.anchor(value);
</span><span class="cx"> m_out.branch(
</span><span class="lines">@@ -1387,9 +1387,9 @@
</span><span class="cx"> {
</span><span class="cx"> LValue value = lowJSValue(m_node->child1());
</span><span class="cx">
</span><del>- LBasicBlock isCellCase = FTL_NEW_BLOCK(m_out, ("ToThis is cell case"));
- LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("ToThis slow case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ToThis continuation"));
</del><ins>+ LBasicBlock isCellCase = m_out.newBlock();
+ LBasicBlock slowCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> isCell(value, provenType(m_node->child1())), usually(isCellCase), rarely(slowCase));
</span><span class="lines">@@ -1522,8 +1522,8 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (shouldCheckNegativeZero(m_node->arithMode())) {
</span><del>- LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("ArithMul slow case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ArithMul continuation"));
</del><ins>+ LBasicBlock slowCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.notZero32(result), usually(continuation), rarely(slowCase));
</span><span class="lines">@@ -1548,8 +1548,8 @@
</span><span class="cx"> blessSpeculation(result, Overflow, noValue(), nullptr, m_origin);
</span><span class="cx">
</span><span class="cx"> if (shouldCheckNegativeZero(m_node->arithMode())) {
</span><del>- LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("ArithMul slow case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ArithMul continuation"));
</del><ins>+ LBasicBlock slowCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.notZero64(result), usually(continuation), rarely(slowCase));
</span><span class="lines">@@ -1590,8 +1590,8 @@
</span><span class="cx"> LValue denominator = lowInt32(m_node->child2());
</span><span class="cx">
</span><span class="cx"> if (shouldCheckNegativeZero(m_node->arithMode())) {
</span><del>- LBasicBlock zeroNumerator = FTL_NEW_BLOCK(m_out, ("ArithDiv zero numerator"));
- LBasicBlock numeratorContinuation = FTL_NEW_BLOCK(m_out, ("ArithDiv numerator continuation"));
</del><ins>+ LBasicBlock zeroNumerator = m_out.newBlock();
+ LBasicBlock numeratorContinuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.isZero32(numerator),
</span><span class="lines">@@ -1608,8 +1608,8 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (shouldCheckOverflow(m_node->arithMode())) {
</span><del>- LBasicBlock unsafeDenominator = FTL_NEW_BLOCK(m_out, ("ArithDiv unsafe denominator"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ArithDiv continuation"));
</del><ins>+ LBasicBlock unsafeDenominator = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue adjustedDenominator = m_out.add(denominator, m_out.int32One);
</span><span class="cx"> m_out.branch(
</span><span class="lines">@@ -1660,8 +1660,8 @@
</span><span class="cx">
</span><span class="cx"> LValue remainder;
</span><span class="cx"> if (shouldCheckOverflow(m_node->arithMode())) {
</span><del>- LBasicBlock unsafeDenominator = FTL_NEW_BLOCK(m_out, ("ArithMod unsafe denominator"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ArithMod continuation"));
</del><ins>+ LBasicBlock unsafeDenominator = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue adjustedDenominator = m_out.add(denominator, m_out.int32One);
</span><span class="cx"> m_out.branch(
</span><span class="lines">@@ -1681,8 +1681,8 @@
</span><span class="cx"> remainder = m_out.chillMod(numerator, denominator);
</span><span class="cx">
</span><span class="cx"> if (shouldCheckNegativeZero(m_node->arithMode())) {
</span><del>- LBasicBlock negativeNumerator = FTL_NEW_BLOCK(m_out, ("ArithMod negative numerator"));
- LBasicBlock numeratorContinuation = FTL_NEW_BLOCK(m_out, ("ArithMod numerator continuation"));
</del><ins>+ LBasicBlock negativeNumerator = m_out.newBlock();
+ LBasicBlock numeratorContinuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.lessThan(numerator, m_out.int32Zero),
</span><span class="lines">@@ -1733,8 +1733,8 @@
</span><span class="cx"> LValue left = lowDouble(m_node->child1());
</span><span class="cx"> LValue right = lowDouble(m_node->child2());
</span><span class="cx">
</span><del>- LBasicBlock notLessThan = FTL_NEW_BLOCK(m_out, ("ArithMin/ArithMax not less than"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ArithMin/ArithMax continuation"));
</del><ins>+ LBasicBlock notLessThan = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> Vector<ValueFromBlock, 2> results;
</span><span class="cx">
</span><span class="lines">@@ -1803,14 +1803,14 @@
</span><span class="cx"> LValue base = lowDouble(m_node->child1());
</span><span class="cx"> LValue exponent = lowDouble(m_node->child2());
</span><span class="cx">
</span><del>- LBasicBlock integerExponentIsSmallBlock = FTL_NEW_BLOCK(m_out, ("ArithPow test integer exponent is small."));
- LBasicBlock integerExponentPowBlock = FTL_NEW_BLOCK(m_out, ("ArithPow pow(double, (int)double)."));
- LBasicBlock doubleExponentPowBlockEntry = FTL_NEW_BLOCK(m_out, ("ArithPow pow(double, double)."));
- LBasicBlock nanExceptionExponentIsInfinity = FTL_NEW_BLOCK(m_out, ("ArithPow NaN Exception, check exponent is infinity."));
- LBasicBlock nanExceptionBaseIsOne = FTL_NEW_BLOCK(m_out, ("ArithPow NaN Exception, check base is one."));
- LBasicBlock powBlock = FTL_NEW_BLOCK(m_out, ("ArithPow regular pow"));
- LBasicBlock nanExceptionResultIsNaN = FTL_NEW_BLOCK(m_out, ("ArithPow NaN Exception, result is NaN."));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ArithPow continuation"));
</del><ins>+ LBasicBlock integerExponentIsSmallBlock = m_out.newBlock();
+ LBasicBlock integerExponentPowBlock = m_out.newBlock();
+ LBasicBlock doubleExponentPowBlockEntry = m_out.newBlock();
+ LBasicBlock nanExceptionExponentIsInfinity = m_out.newBlock();
+ LBasicBlock nanExceptionBaseIsOne = m_out.newBlock();
+ LBasicBlock powBlock = m_out.newBlock();
+ LBasicBlock nanExceptionResultIsNaN = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue integerExponent = m_out.doubleToInt(exponent);
</span><span class="cx"> LValue integerExponentConvertedToDouble = m_out.intToDouble(integerExponent);
</span><span class="lines">@@ -1914,8 +1914,8 @@
</span><span class="cx"> LValue value = lowDouble(m_node->child1());
</span><span class="cx"> result = m_out.doubleFloor(m_out.doubleAdd(value, m_out.constDouble(0.5)));
</span><span class="cx"> } else {
</span><del>- LBasicBlock realPartIsMoreThanHalf = FTL_NEW_BLOCK(m_out, ("ArithRound should round down"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ArithRound continuation"));
</del><ins>+ LBasicBlock realPartIsMoreThanHalf = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue value = lowDouble(m_node->child1());
</span><span class="cx"> LValue integerValue = m_out.doubleCeil(value);
</span><span class="lines">@@ -2120,9 +2120,9 @@
</span><span class="cx"> case CellOrOtherUse: {
</span><span class="cx"> LValue value = lowJSValue(m_node->child1(), ManualOperandSpeculation);
</span><span class="cx">
</span><del>- LBasicBlock cellCase = FTL_NEW_BLOCK(m_out, ("CheckStructure CellOrOtherUse cell case"));
- LBasicBlock notCellCase = FTL_NEW_BLOCK(m_out, ("CheckStructure CellOrOtherUse not cell case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("CheckStructure CellOrOtherUse continuation"));
</del><ins>+ LBasicBlock cellCase = m_out.newBlock();
+ LBasicBlock notCellCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> isCell(value, provenType(m_node->child1())), unsure(cellCase), unsure(notCellCase));
</span><span class="lines">@@ -2195,8 +2195,8 @@
</span><span class="cx"> LValue cell = lowCell(m_node->child1());
</span><span class="cx"> LValue property = !!m_node->child2() ? lowInt32(m_node->child2()) : 0;
</span><span class="cx">
</span><del>- LBasicBlock unexpectedStructure = FTL_NEW_BLOCK(m_out, ("ArrayifyToStructure unexpected structure"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ArrayifyToStructure continuation"));
</del><ins>+ LBasicBlock unexpectedStructure = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue structureID = m_out.load32(cell, m_heaps.JSCell_structureID);
</span><span class="cx">
</span><span class="lines">@@ -2278,9 +2278,9 @@
</span><span class="cx"> // https://bugs.webkit.org/show_bug.cgi?id=127830
</span><span class="cx"> LValue value = lowJSValue(m_node->child1());
</span><span class="cx">
</span><del>- LBasicBlock cellCase = FTL_NEW_BLOCK(m_out, ("GetById untyped cell case"));
- LBasicBlock notCellCase = FTL_NEW_BLOCK(m_out, ("GetById untyped not cell case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("GetById untyped continuation"));
</del><ins>+ LBasicBlock cellCase = m_out.newBlock();
+ LBasicBlock notCellCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> isCell(value, provenType(m_node->child1())), unsure(cellCase), unsure(notCellCase));
</span><span class="lines">@@ -2397,8 +2397,8 @@
</span><span class="cx"> LValue cell = lowCell(m_node->child1());
</span><span class="cx">
</span><span class="cx"> if (m_node->arrayMode().type() == Array::String) {
</span><del>- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("GetIndexedPropertyStorage String slow case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("GetIndexedPropertyStorage String continuation"));
</del><ins>+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue fastResultValue = m_out.loadPtr(cell, m_heaps.JSString_value);
</span><span class="cx"> ValueFromBlock fastResult = m_out.anchor(fastResultValue);
</span><span class="lines">@@ -2439,9 +2439,9 @@
</span><span class="cx"> {
</span><span class="cx"> LValue basePtr = lowCell(m_node->child1());
</span><span class="cx">
</span><del>- LBasicBlock simpleCase = FTL_NEW_BLOCK(m_out, ("GetTypedArrayByteOffset wasteless typed array"));
- LBasicBlock wastefulCase = FTL_NEW_BLOCK(m_out, ("GetTypedArrayByteOffset wasteful typed array"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("GetTypedArrayByteOffset continuation"));
</del><ins>+ LBasicBlock simpleCase = m_out.newBlock();
+ LBasicBlock wastefulCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue mode = m_out.load32(basePtr, m_heaps.JSArrayBufferView_mode);
</span><span class="cx"> m_out.branch(
</span><span class="lines">@@ -2549,9 +2549,9 @@
</span><span class="cx">
</span><span class="cx"> LValue base = lowCell(m_node->child1());
</span><span class="cx">
</span><del>- LBasicBlock fastCase = FTL_NEW_BLOCK(m_out, ("GetByVal int/contiguous fast case"));
- LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("GetByVal int/contiguous slow case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("GetByVal int/contiguous continuation"));
</del><ins>+ LBasicBlock fastCase = m_out.newBlock();
+ LBasicBlock slowCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.aboveOrEqual(
</span><span class="lines">@@ -2596,10 +2596,10 @@
</span><span class="cx">
</span><span class="cx"> LValue base = lowCell(m_node->child1());
</span><span class="cx">
</span><del>- LBasicBlock inBounds = FTL_NEW_BLOCK(m_out, ("GetByVal double in bounds"));
- LBasicBlock boxPath = FTL_NEW_BLOCK(m_out, ("GetByVal double boxing"));
- LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("GetByVal double slow case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("GetByVal double continuation"));
</del><ins>+ LBasicBlock inBounds = m_out.newBlock();
+ LBasicBlock boxPath = m_out.newBlock();
+ LBasicBlock slowCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.aboveOrEqual(
</span><span class="lines">@@ -2667,9 +2667,9 @@
</span><span class="cx"> LValue table = m_out.loadPtr(base, m_heaps.ScopedArguments_table);
</span><span class="cx"> LValue namedLength = m_out.load32(table, m_heaps.ScopedArgumentsTable_length);
</span><span class="cx">
</span><del>- LBasicBlock namedCase = FTL_NEW_BLOCK(m_out, ("GetByVal ScopedArguments named case"));
- LBasicBlock overflowCase = FTL_NEW_BLOCK(m_out, ("GetByVal ScopedArguments overflow case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("GetByVal ScopedArguments continuation"));
</del><ins>+ LBasicBlock namedCase = m_out.newBlock();
+ LBasicBlock overflowCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.aboveOrEqual(index, namedLength), unsure(overflowCase), unsure(namedCase));
</span><span class="lines">@@ -2875,7 +2875,7 @@
</span><span class="cx"> case Array::Int32:
</span><span class="cx"> case Array::Double:
</span><span class="cx"> case Array::Contiguous: {
</span><del>- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("PutByVal continuation"));
</del><ins>+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx"> LBasicBlock outerLastNext = m_out.appendTo(m_out.m_block, continuation);
</span><span class="cx">
</span><span class="cx"> switch (m_node->arrayMode().type()) {
</span><span class="lines">@@ -2969,8 +2969,8 @@
</span><span class="cx"> if (isClamped(type)) {
</span><span class="cx"> ASSERT(elementSize(type) == 1);
</span><span class="cx">
</span><del>- LBasicBlock atLeastZero = FTL_NEW_BLOCK(m_out, ("PutByVal int clamp atLeastZero"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("PutByVal int clamp continuation"));
</del><ins>+ LBasicBlock atLeastZero = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> Vector<ValueFromBlock, 2> intValues;
</span><span class="cx"> intValues.append(m_out.anchor(m_out.int32Zero));
</span><span class="lines">@@ -2998,9 +2998,9 @@
</span><span class="cx"> if (isClamped(type)) {
</span><span class="cx"> ASSERT(elementSize(type) == 1);
</span><span class="cx">
</span><del>- LBasicBlock atLeastZero = FTL_NEW_BLOCK(m_out, ("PutByVal double clamp atLeastZero"));
- LBasicBlock withinRange = FTL_NEW_BLOCK(m_out, ("PutByVal double clamp withinRange"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("PutByVal double clamp continuation"));
</del><ins>+ LBasicBlock atLeastZero = m_out.newBlock();
+ LBasicBlock withinRange = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> Vector<ValueFromBlock, 3> intValues;
</span><span class="cx"> intValues.append(m_out.anchor(m_out.int32Zero));
</span><span class="lines">@@ -3062,8 +3062,8 @@
</span><span class="cx"> if (m_node->arrayMode().isInBounds() || m_node->op() == PutByValAlias)
</span><span class="cx"> m_out.store(valueToStore, pointer, storeType);
</span><span class="cx"> else {
</span><del>- LBasicBlock isInBounds = FTL_NEW_BLOCK(m_out, ("PutByVal typed array in bounds case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("PutByVal typed array continuation"));
</del><ins>+ LBasicBlock isInBounds = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.aboveOrEqual(index, lowInt32(child5)),
</span><span class="lines">@@ -3149,9 +3149,9 @@
</span><span class="cx">
</span><span class="cx"> LValue prevLength = m_out.load32(storage, m_heaps.Butterfly_publicLength);
</span><span class="cx">
</span><del>- LBasicBlock fastPath = FTL_NEW_BLOCK(m_out, ("ArrayPush fast path"));
- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("ArrayPush slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ArrayPush continuation"));
</del><ins>+ LBasicBlock fastPath = m_out.newBlock();
+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.aboveOrEqual(
</span><span class="lines">@@ -3199,9 +3199,9 @@
</span><span class="cx"> case Array::Contiguous: {
</span><span class="cx"> IndexedAbstractHeap& heap = m_heaps.forArrayType(m_node->arrayMode().type());
</span><span class="cx">
</span><del>- LBasicBlock fastCase = FTL_NEW_BLOCK(m_out, ("ArrayPop fast case"));
- LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("ArrayPop slow case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ArrayPop continuation"));
</del><ins>+ LBasicBlock fastCase = m_out.newBlock();
+ LBasicBlock slowCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue prevLength = m_out.load32(storage, m_heaps.Butterfly_publicLength);
</span><span class="cx">
</span><span class="lines">@@ -3261,8 +3261,8 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("CreateActivation slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("CreateActivation continuation"));
</del><ins>+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.insertNewBlocksBefore(slowPath);
</span><span class="cx">
</span><span class="lines">@@ -3320,8 +3320,8 @@
</span><span class="cx"> isGeneratorFunction ? m_graph.globalObjectFor(m_node->origin.semantic)->generatorFunctionStructure() :
</span><span class="cx"> m_graph.globalObjectFor(m_node->origin.semantic)->functionStructure();
</span><span class="cx">
</span><del>- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("NewFunction slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("NewFunction continuation"));
</del><ins>+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.insertNewBlocksBefore(slowPath);
</span><span class="cx">
</span><span class="lines">@@ -3375,8 +3375,8 @@
</span><span class="cx">
</span><span class="cx"> unsigned minCapacity = m_graph.baselineCodeBlockFor(m_node->origin.semantic)->numParameters() - 1;
</span><span class="cx">
</span><del>- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("CreateDirectArguments slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("CreateDirectArguments continuation"));
</del><ins>+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.insertNewBlocksBefore(slowPath);
</span><span class="cx">
</span><span class="lines">@@ -3433,8 +3433,8 @@
</span><span class="cx"> } else {
</span><span class="cx"> LValue stackBase = getArgumentsStart();
</span><span class="cx">
</span><del>- LBasicBlock loop = FTL_NEW_BLOCK(m_out, ("CreateDirectArguments loop body"));
- LBasicBlock end = FTL_NEW_BLOCK(m_out, ("CreateDirectArguments loop end"));
</del><ins>+ LBasicBlock loop = m_out.newBlock();
+ LBasicBlock end = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> ValueFromBlock originalLength;
</span><span class="cx"> if (minCapacity) {
</span><span class="lines">@@ -3493,8 +3493,8 @@
</span><span class="cx">
</span><span class="cx"> void compileCopyRest()
</span><span class="cx"> {
</span><del>- LBasicBlock doCopyRest = FTL_NEW_BLOCK(m_out, ("CopyRest C call"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("FillRestParameter continuation"));
</del><ins>+ LBasicBlock doCopyRest = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue arrayLength = lowInt32(m_node->child2());
</span><span class="cx">
</span><span class="lines">@@ -3515,8 +3515,8 @@
</span><span class="cx">
</span><span class="cx"> void compileGetRestLength()
</span><span class="cx"> {
</span><del>- LBasicBlock nonZeroLength = FTL_NEW_BLOCK(m_out, ("GetRestLength non zero"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("GetRestLength continuation"));
</del><ins>+ LBasicBlock nonZeroLength = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> ValueFromBlock zeroLengthResult = m_out.anchor(m_out.constInt32(0));
</span><span class="cx">
</span><span class="lines">@@ -3672,11 +3672,11 @@
</span><span class="cx"> || hasDouble(structure->indexingType())
</span><span class="cx"> || hasContiguous(structure->indexingType()));
</span><span class="cx">
</span><del>- LBasicBlock fastCase = FTL_NEW_BLOCK(m_out, ("NewArrayWithSize fast case"));
- LBasicBlock largeCase = FTL_NEW_BLOCK(m_out, ("NewArrayWithSize large case"));
- LBasicBlock failCase = FTL_NEW_BLOCK(m_out, ("NewArrayWithSize fail case"));
- LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("NewArrayWithSize slow case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("NewArrayWithSize continuation"));
</del><ins>+ LBasicBlock fastCase = m_out.newBlock();
+ LBasicBlock largeCase = m_out.newBlock();
+ LBasicBlock failCase = m_out.newBlock();
+ LBasicBlock slowCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.aboveOrEqual(publicLength, m_out.constInt32(MIN_ARRAY_STORAGE_CONSTRUCTION_LENGTH)),
</span><span class="lines">@@ -3703,8 +3703,8 @@
</span><span class="cx"> m_out.store32(vectorLength, butterfly, m_heaps.Butterfly_vectorLength);
</span><span class="cx">
</span><span class="cx"> if (hasDouble(m_node->indexingType())) {
</span><del>- LBasicBlock initLoop = FTL_NEW_BLOCK(m_out, ("NewArrayWithSize double init loop"));
- LBasicBlock initDone = FTL_NEW_BLOCK(m_out, ("NewArrayWithSize double init done"));
</del><ins>+ LBasicBlock initLoop = m_out.newBlock();
+ LBasicBlock initDone = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> ValueFromBlock originalIndex = m_out.anchor(vectorLength);
</span><span class="cx"> ValueFromBlock originalPointer = m_out.anchor(butterfly);
</span><span class="lines">@@ -3777,10 +3777,10 @@
</span><span class="cx">
</span><span class="cx"> LValue size = lowInt32(m_node->child1());
</span><span class="cx">
</span><del>- LBasicBlock smallEnoughCase = FTL_NEW_BLOCK(m_out, ("NewTypedArray small enough case"));
- LBasicBlock nonZeroCase = FTL_NEW_BLOCK(m_out, ("NewTypedArray non-zero case"));
- LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("NewTypedArray slow case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("NewTypedArray continuation"));
</del><ins>+ LBasicBlock smallEnoughCase = m_out.newBlock();
+ LBasicBlock nonZeroCase = m_out.newBlock();
+ LBasicBlock slowCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.above(size, m_out.constInt32(JSArrayBufferView::fastSizeLimit)),
</span><span class="lines">@@ -3879,8 +3879,8 @@
</span><span class="cx"> LValue cell = lowCell(m_node->child1());
</span><span class="cx"> LValue structureID = m_out.load32(cell, m_heaps.JSCell_structureID);
</span><span class="cx">
</span><del>- LBasicBlock notString = FTL_NEW_BLOCK(m_out, ("ToString StringOrStringObject not string case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ToString StringOrStringObject continuation"));
</del><ins>+ LBasicBlock notString = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> ValueFromBlock simpleResult = m_out.anchor(cell);
</span><span class="cx"> m_out.branch(
</span><span class="lines">@@ -3908,9 +3908,9 @@
</span><span class="cx"> else
</span><span class="cx"> value = lowJSValue(m_node->child1());
</span><span class="cx">
</span><del>- LBasicBlock isCell = FTL_NEW_BLOCK(m_out, ("ToString CellUse/UntypedUse is cell"));
- LBasicBlock notString = FTL_NEW_BLOCK(m_out, ("ToString CellUse/UntypedUse not string"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ToString CellUse/UntypedUse continuation"));
</del><ins>+ LBasicBlock isCell = m_out.newBlock();
+ LBasicBlock notString = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue isCellPredicate;
</span><span class="cx"> if (m_node->child1().useKind() == CellUse)
</span><span class="lines">@@ -3952,9 +3952,9 @@
</span><span class="cx"> {
</span><span class="cx"> LValue value = lowJSValue(m_node->child1());
</span><span class="cx">
</span><del>- LBasicBlock isCellCase = FTL_NEW_BLOCK(m_out, ("ToPrimitive cell case"));
- LBasicBlock isObjectCase = FTL_NEW_BLOCK(m_out, ("ToPrimitive object case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ToPrimitive continuation"));
</del><ins>+ LBasicBlock isCellCase = m_out.newBlock();
+ LBasicBlock isObjectCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> Vector<ValueFromBlock, 3> results;
</span><span class="cx">
</span><span class="lines">@@ -3991,8 +3991,8 @@
</span><span class="cx"> numKids = 2;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("MakeRope slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("MakeRope continuation"));
</del><ins>+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.insertNewBlocksBefore(slowPath);
</span><span class="cx">
</span><span class="lines">@@ -4062,9 +4062,9 @@
</span><span class="cx"> LValue index = lowInt32(m_node->child2());
</span><span class="cx"> LValue storage = lowStorage(m_node->child3());
</span><span class="cx">
</span><del>- LBasicBlock fastPath = FTL_NEW_BLOCK(m_out, ("GetByVal String fast path"));
- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("GetByVal String slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("GetByVal String continuation"));
</del><ins>+ LBasicBlock fastPath = m_out.newBlock();
+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.aboveOrEqual(
</span><span class="lines">@@ -4075,10 +4075,10 @@
</span><span class="cx">
</span><span class="cx"> LValue stringImpl = m_out.loadPtr(base, m_heaps.JSString_value);
</span><span class="cx">
</span><del>- LBasicBlock is8Bit = FTL_NEW_BLOCK(m_out, ("GetByVal String 8-bit case"));
- LBasicBlock is16Bit = FTL_NEW_BLOCK(m_out, ("GetByVal String 16-bit case"));
- LBasicBlock bitsContinuation = FTL_NEW_BLOCK(m_out, ("GetByVal String bitness continuation"));
- LBasicBlock bigCharacter = FTL_NEW_BLOCK(m_out, ("GetByVal String big character"));
</del><ins>+ LBasicBlock is8Bit = m_out.newBlock();
+ LBasicBlock is16Bit = m_out.newBlock();
+ LBasicBlock bitsContinuation = m_out.newBlock();
+ LBasicBlock bigCharacter = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.testIsZero32(
</span><span class="lines">@@ -4140,7 +4140,7 @@
</span><span class="cx"> m_graph.watchpoints().addLazily(globalObject->stringPrototype()->structure()->transitionWatchpointSet());
</span><span class="cx"> m_graph.watchpoints().addLazily(globalObject->objectPrototype()->structure()->transitionWatchpointSet());
</span><span class="cx">
</span><del>- LBasicBlock negativeIndex = FTL_NEW_BLOCK(m_out, ("GetByVal String negative index"));
</del><ins>+ LBasicBlock negativeIndex = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> results.append(m_out.anchor(m_out.constInt64(JSValue::encode(jsUndefined()))));
</span><span class="cx"> m_out.branch(
</span><span class="lines">@@ -4162,9 +4162,9 @@
</span><span class="cx">
</span><span class="cx"> void compileStringCharCodeAt()
</span><span class="cx"> {
</span><del>- LBasicBlock is8Bit = FTL_NEW_BLOCK(m_out, ("StringCharCodeAt 8-bit case"));
- LBasicBlock is16Bit = FTL_NEW_BLOCK(m_out, ("StringCharCodeAt 16-bit case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("StringCharCodeAt continuation"));
</del><ins>+ LBasicBlock is8Bit = m_out.newBlock();
+ LBasicBlock is16Bit = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue base = lowCell(m_node->child1());
</span><span class="cx"> LValue index = lowInt32(m_node->child2());
</span><span class="lines">@@ -4220,9 +4220,9 @@
</span><span class="cx">
</span><span class="cx"> LValue value = lowInt32(childEdge);
</span><span class="cx">
</span><del>- LBasicBlock smallIntCase = FTL_NEW_BLOCK(m_out, ("StringFromCharCode small int case"));
- LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("StringFromCharCode slow case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("StringFromCharCode continuation"));
</del><ins>+ LBasicBlock smallIntCase = m_out.newBlock();
+ LBasicBlock slowCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.aboveOrEqual(value, m_out.constInt32(0xff)),
</span><span class="lines">@@ -4282,9 +4282,9 @@
</span><span class="cx">
</span><span class="cx"> Vector<LBasicBlock, 2> blocks(data.cases.size());
</span><span class="cx"> for (unsigned i = data.cases.size(); i--;)
</span><del>- blocks[i] = FTL_NEW_BLOCK(m_out, ("MultiGetByOffset case ", i));
- LBasicBlock exit = FTL_NEW_BLOCK(m_out, ("MultiGetByOffset fail"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("MultiGetByOffset continuation"));
</del><ins>+ blocks[i] = m_out.newBlock();
+ LBasicBlock exit = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> Vector<SwitchCase, 2> cases;
</span><span class="cx"> StructureSet baseSet;
</span><span class="lines">@@ -4364,9 +4364,9 @@
</span><span class="cx">
</span><span class="cx"> Vector<LBasicBlock, 2> blocks(data.variants.size());
</span><span class="cx"> for (unsigned i = data.variants.size(); i--;)
</span><del>- blocks[i] = FTL_NEW_BLOCK(m_out, ("MultiPutByOffset case ", i));
- LBasicBlock exit = FTL_NEW_BLOCK(m_out, ("MultiPutByOffset fail"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("MultiPutByOffset continuation"));
</del><ins>+ blocks[i] = m_out.newBlock();
+ LBasicBlock exit = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> Vector<SwitchCase, 2> cases;
</span><span class="cx"> StructureSet baseSet;
</span><span class="lines">@@ -4439,8 +4439,8 @@
</span><span class="cx"> {
</span><span class="cx"> WatchpointSet* set = m_node->watchpointSet();
</span><span class="cx">
</span><del>- LBasicBlock isNotInvalidated = FTL_NEW_BLOCK(m_out, ("NotifyWrite not invalidated case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("NotifyWrite continuation"));
</del><ins>+ LBasicBlock isNotInvalidated = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue state = m_out.load8ZeroExt32(m_out.absolute(set->addressOfState()));
</span><span class="cx"> m_out.branch(
</span><span class="lines">@@ -4597,8 +4597,8 @@
</span><span class="cx"> LValue left = lowCell(m_node->child1());
</span><span class="cx"> LValue right = lowCell(m_node->child2());
</span><span class="cx">
</span><del>- LBasicBlock notTriviallyEqualCase = FTL_NEW_BLOCK(m_out, ("CompareStrictEq/String not trivially equal case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("CompareStrictEq/String continuation"));
</del><ins>+ LBasicBlock notTriviallyEqualCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> speculateString(m_node->child1(), left);
</span><span class="cx">
</span><span class="lines">@@ -4675,9 +4675,9 @@
</span><span class="cx"> LValue left = lowStringIdent(leftEdge);
</span><span class="cx"> LValue rightValue = lowJSValue(rightEdge, ManualOperandSpeculation);
</span><span class="cx">
</span><del>- LBasicBlock isCellCase = FTL_NEW_BLOCK(m_out, ("CompareStrictEq StringIdent to NotStringVar is cell case"));
- LBasicBlock isStringCase = FTL_NEW_BLOCK(m_out, ("CompareStrictEq StringIdent to NotStringVar is string case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("CompareStrictEq StringIdent to NotStringVar continuation"));
</del><ins>+ LBasicBlock isCellCase = m_out.newBlock();
+ LBasicBlock isStringCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> ValueFromBlock notCellResult = m_out.anchor(m_out.booleanFalse);
</span><span class="cx"> m_out.branch(
</span><span class="lines">@@ -5293,10 +5293,10 @@
</span><span class="cx"> LValue sourceStart = getArgumentsStart(inlineCallFrame);
</span><span class="cx"> LValue targetStart = addressFor(data->machineStart).value();
</span><span class="cx">
</span><del>- LBasicBlock undefinedLoop = FTL_NEW_BLOCK(m_out, ("ForwardVarargs undefined loop body"));
- LBasicBlock mainLoopEntry = FTL_NEW_BLOCK(m_out, ("ForwardVarargs main loop entry"));
- LBasicBlock mainLoop = FTL_NEW_BLOCK(m_out, ("ForwardVarargs main loop body"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ForwardVarargs continuation"));
</del><ins>+ LBasicBlock undefinedLoop = m_out.newBlock();
+ LBasicBlock mainLoopEntry = m_out.newBlock();
+ LBasicBlock mainLoop = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue lengthAsPtr = m_out.zeroExtPtr(length);
</span><span class="cx"> LValue loopBoundValue = m_out.constIntPtr(data->mandatoryMinimum);
</span><span class="lines">@@ -5357,7 +5357,7 @@
</span><span class="cx"> switch (data->kind) {
</span><span class="cx"> case SwitchImm: {
</span><span class="cx"> Vector<ValueFromBlock, 2> intValues;
</span><del>- LBasicBlock switchOnInts = FTL_NEW_BLOCK(m_out, ("Switch/SwitchImm int case"));
</del><ins>+ LBasicBlock switchOnInts = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(m_out.m_block, switchOnInts);
</span><span class="cx">
</span><span class="lines">@@ -5369,9 +5369,9 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> case UntypedUse: {
</span><del>- LBasicBlock isInt = FTL_NEW_BLOCK(m_out, ("Switch/SwitchImm is int"));
- LBasicBlock isNotInt = FTL_NEW_BLOCK(m_out, ("Switch/SwitchImm is not int"));
- LBasicBlock isDouble = FTL_NEW_BLOCK(m_out, ("Switch/SwitchImm is double"));
</del><ins>+ LBasicBlock isInt = m_out.newBlock();
+ LBasicBlock isNotInt = m_out.newBlock();
+ LBasicBlock isDouble = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue boxedValue = lowJSValue(m_node->child1());
</span><span class="cx"> m_out.branch(isNotInt32(boxedValue), unsure(isNotInt), unsure(isInt));
</span><span class="lines">@@ -5424,8 +5424,8 @@
</span><span class="cx"> case UntypedUse: {
</span><span class="cx"> LValue unboxedValue = lowJSValue(m_node->child1());
</span><span class="cx">
</span><del>- LBasicBlock isCellCase = FTL_NEW_BLOCK(m_out, ("Switch/SwitchChar is cell"));
- LBasicBlock isStringCase = FTL_NEW_BLOCK(m_out, ("Switch/SwitchChar is string"));
</del><ins>+ LBasicBlock isCellCase = m_out.newBlock();
+ LBasicBlock isStringCase = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> isNotCell(unboxedValue, provenType(m_node->child1())),
</span><span class="lines">@@ -5447,12 +5447,12 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- LBasicBlock lengthIs1 = FTL_NEW_BLOCK(m_out, ("Switch/SwitchChar length is 1"));
- LBasicBlock needResolution = FTL_NEW_BLOCK(m_out, ("Switch/SwitchChar resolution"));
- LBasicBlock resolved = FTL_NEW_BLOCK(m_out, ("Switch/SwitchChar resolved"));
- LBasicBlock is8Bit = FTL_NEW_BLOCK(m_out, ("Switch/SwitchChar 8bit"));
- LBasicBlock is16Bit = FTL_NEW_BLOCK(m_out, ("Switch/SwitchChar 16bit"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("Switch/SwitchChar continuation"));
</del><ins>+ LBasicBlock lengthIs1 = m_out.newBlock();
+ LBasicBlock needResolution = m_out.newBlock();
+ LBasicBlock resolved = m_out.newBlock();
+ LBasicBlock is8Bit = m_out.newBlock();
+ LBasicBlock is16Bit = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.notEqual(
</span><span class="lines">@@ -5521,8 +5521,8 @@
</span><span class="cx"> case UntypedUse: {
</span><span class="cx"> LValue value = lowJSValue(m_node->child1());
</span><span class="cx">
</span><del>- LBasicBlock isCellBlock = FTL_NEW_BLOCK(m_out, ("Switch/SwitchString Untyped cell case"));
- LBasicBlock isStringBlock = FTL_NEW_BLOCK(m_out, ("Switch/SwitchString Untyped string case"));
</del><ins>+ LBasicBlock isCellBlock = m_out.newBlock();
+ LBasicBlock isStringBlock = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> isCell(value, provenType(m_node->child1())),
</span><span class="lines">@@ -5557,7 +5557,7 @@
</span><span class="cx">
</span><span class="cx"> case UntypedUse: {
</span><span class="cx"> LValue value = lowJSValue(m_node->child1());
</span><del>- LBasicBlock cellCase = FTL_NEW_BLOCK(m_out, ("Switch/SwitchCell cell case"));
</del><ins>+ LBasicBlock cellCase = m_out.newBlock();
</ins><span class="cx"> m_out.branch(
</span><span class="cx"> isCell(value, provenType(m_node->child1())),
</span><span class="cx"> unsure(cellCase), unsure(lowBlock(data->fallThrough.block)));
</span><span class="lines">@@ -5667,8 +5667,8 @@
</span><span class="cx"> {
</span><span class="cx"> LValue value = lowJSValue(m_node->child1());
</span><span class="cx">
</span><del>- LBasicBlock isCellCase = FTL_NEW_BLOCK(m_out, ("IsString cell case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("IsString continuation"));
</del><ins>+ LBasicBlock isCellCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> ValueFromBlock notCellResult = m_out.anchor(m_out.booleanFalse);
</span><span class="cx"> m_out.branch(
</span><span class="lines">@@ -5686,8 +5686,8 @@
</span><span class="cx"> {
</span><span class="cx"> LValue value = lowJSValue(m_node->child1());
</span><span class="cx">
</span><del>- LBasicBlock isCellCase = FTL_NEW_BLOCK(m_out, ("IsObject cell case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("IsObject continuation"));
</del><ins>+ LBasicBlock isCellCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> ValueFromBlock notCellResult = m_out.anchor(m_out.booleanFalse);
</span><span class="cx"> m_out.branch(
</span><span class="lines">@@ -5708,12 +5708,12 @@
</span><span class="cx"> Edge child = m_node->child1();
</span><span class="cx"> LValue value = lowJSValue(child);
</span><span class="cx">
</span><del>- LBasicBlock cellCase = FTL_NEW_BLOCK(m_out, ("IsObjectOrNull cell case"));
- LBasicBlock notFunctionCase = FTL_NEW_BLOCK(m_out, ("IsObjectOrNull not function case"));
- LBasicBlock objectCase = FTL_NEW_BLOCK(m_out, ("IsObjectOrNull object case"));
- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("IsObjectOrNull slow path"));
- LBasicBlock notCellCase = FTL_NEW_BLOCK(m_out, ("IsObjectOrNull not cell case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("IsObjectOrNull continuation"));
</del><ins>+ LBasicBlock cellCase = m_out.newBlock();
+ LBasicBlock notFunctionCase = m_out.newBlock();
+ LBasicBlock objectCase = m_out.newBlock();
+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock notCellCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(isCell(value, provenType(child)), unsure(cellCase), unsure(notCellCase));
</span><span class="cx">
</span><span class="lines">@@ -5764,10 +5764,10 @@
</span><span class="cx"> Edge child = m_node->child1();
</span><span class="cx"> LValue value = lowJSValue(child);
</span><span class="cx">
</span><del>- LBasicBlock cellCase = FTL_NEW_BLOCK(m_out, ("IsFunction cell case"));
- LBasicBlock notFunctionCase = FTL_NEW_BLOCK(m_out, ("IsFunction not function case"));
- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("IsFunction slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("IsFunction continuation"));
</del><ins>+ LBasicBlock cellCase = m_out.newBlock();
+ LBasicBlock notFunctionCase = m_out.newBlock();
+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> ValueFromBlock notCellResult = m_out.anchor(m_out.booleanFalse);
</span><span class="cx"> m_out.branch(
</span><span class="lines">@@ -5806,7 +5806,7 @@
</span><span class="cx"> Edge child = m_node->child1();
</span><span class="cx"> LValue value = lowJSValue(child);
</span><span class="cx">
</span><del>- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("TypeOf continuation"));
</del><ins>+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx"> LBasicBlock lastNext = m_out.insertNewBlocksBefore(continuation);
</span><span class="cx">
</span><span class="cx"> Vector<ValueFromBlock> results;
</span><span class="lines">@@ -5903,8 +5903,8 @@
</span><span class="cx"> LValue constructor = lowCell(m_node->child1());
</span><span class="cx"> LValue hasInstance = lowJSValue(m_node->child2());
</span><span class="cx">
</span><del>- LBasicBlock defaultHasInstance = FTL_NEW_BLOCK(m_out, ("OverridesHasInstance Symbol.hasInstance is default"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("OverridesHasInstance continuation"));
</del><ins>+ LBasicBlock defaultHasInstance = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> // Unlike in the DFG, we don't worry about cleaning this code up for the case where we have proven the hasInstanceValue is a constant as B3 should fix it for us.
</span><span class="cx">
</span><span class="lines">@@ -5943,10 +5943,10 @@
</span><span class="cx">
</span><span class="cx"> LValue prototype = lowCell(m_node->child2());
</span><span class="cx">
</span><del>- LBasicBlock isCellCase = FTL_NEW_BLOCK(m_out, ("InstanceOf cell case"));
- LBasicBlock loop = FTL_NEW_BLOCK(m_out, ("InstanceOf loop"));
- LBasicBlock notYetInstance = FTL_NEW_BLOCK(m_out, ("InstanceOf not yet instance"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("InstanceOf continuation"));
</del><ins>+ LBasicBlock isCellCase = m_out.newBlock();
+ LBasicBlock loop = m_out.newBlock();
+ LBasicBlock notYetInstance = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx"> LBasicBlock loadPrototypeDirect = FTL_NEW_BLOCK(m_out, ("Instanceof defaultPrototypeFunction"));
</span><span class="cx"> LBasicBlock defaultHasInstanceSlow = FTL_NEW_BLOCK(m_out, ("Instanceof defaultPrototypeFunction"));
</span><span class="cx">
</span><span class="lines">@@ -6031,9 +6031,9 @@
</span><span class="cx"> IndexedAbstractHeap& heap = m_node->arrayMode().type() == Array::Int32 ?
</span><span class="cx"> m_heaps.indexedInt32Properties : m_heaps.indexedContiguousProperties;
</span><span class="cx">
</span><del>- LBasicBlock checkHole = FTL_NEW_BLOCK(m_out, ("HasIndexedProperty int/contiguous check hole"));
- LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("HasIndexedProperty int/contiguous slow case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("HasIndexedProperty int/contiguous continuation"));
</del><ins>+ LBasicBlock checkHole = m_out.newBlock();
+ LBasicBlock slowCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> if (!m_node->arrayMode().isInBounds()) {
</span><span class="cx"> m_out.branch(
</span><span class="lines">@@ -6066,9 +6066,9 @@
</span><span class="cx">
</span><span class="cx"> IndexedAbstractHeap& heap = m_heaps.indexedDoubleProperties;
</span><span class="cx">
</span><del>- LBasicBlock checkHole = FTL_NEW_BLOCK(m_out, ("HasIndexedProperty double check hole"));
- LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("HasIndexedProperty double slow case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("HasIndexedProperty double continuation"));
</del><ins>+ LBasicBlock checkHole = m_out.newBlock();
+ LBasicBlock slowCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> if (!m_node->arrayMode().isInBounds()) {
</span><span class="cx"> m_out.branch(
</span><span class="lines">@@ -6114,9 +6114,9 @@
</span><span class="cx"> LValue property = lowString(m_node->child2());
</span><span class="cx"> LValue enumerator = lowCell(m_node->child3());
</span><span class="cx">
</span><del>- LBasicBlock correctStructure = FTL_NEW_BLOCK(m_out, ("HasStructureProperty correct structure"));
- LBasicBlock wrongStructure = FTL_NEW_BLOCK(m_out, ("HasStructureProperty wrong structure"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("HasStructureProperty continuation"));
</del><ins>+ LBasicBlock correctStructure = m_out.newBlock();
+ LBasicBlock wrongStructure = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(m_out.notEqual(
</span><span class="cx"> m_out.load32(base, m_heaps.JSCell_structureID),
</span><span class="lines">@@ -6145,11 +6145,11 @@
</span><span class="cx"> LValue index = lowInt32(m_graph.varArgChild(m_node, 2));
</span><span class="cx"> LValue enumerator = lowCell(m_graph.varArgChild(m_node, 3));
</span><span class="cx">
</span><del>- LBasicBlock checkOffset = FTL_NEW_BLOCK(m_out, ("GetDirectPname check offset"));
- LBasicBlock inlineLoad = FTL_NEW_BLOCK(m_out, ("GetDirectPname inline load"));
- LBasicBlock outOfLineLoad = FTL_NEW_BLOCK(m_out, ("GetDirectPname out-of-line load"));
- LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("GetDirectPname slow case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("GetDirectPname continuation"));
</del><ins>+ LBasicBlock checkOffset = m_out.newBlock();
+ LBasicBlock inlineLoad = m_out.newBlock();
+ LBasicBlock outOfLineLoad = m_out.newBlock();
+ LBasicBlock slowCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(m_out.notEqual(
</span><span class="cx"> m_out.load32(base, m_heaps.JSCell_structureID),
</span><span class="lines">@@ -6201,9 +6201,9 @@
</span><span class="cx"> LValue enumerator = lowCell(m_node->child1());
</span><span class="cx"> LValue index = lowInt32(m_node->child2());
</span><span class="cx">
</span><del>- LBasicBlock inBounds = FTL_NEW_BLOCK(m_out, ("GetEnumeratorStructurePname in bounds"));
- LBasicBlock outOfBounds = FTL_NEW_BLOCK(m_out, ("GetEnumeratorStructurePname out of bounds"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("GetEnumeratorStructurePname continuation"));
</del><ins>+ LBasicBlock inBounds = m_out.newBlock();
+ LBasicBlock outOfBounds = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(m_out.below(index, m_out.load32(enumerator, m_heaps.JSPropertyNameEnumerator_endStructurePropertyIndex)),
</span><span class="cx"> usually(inBounds), rarely(outOfBounds));
</span><span class="lines">@@ -6227,9 +6227,9 @@
</span><span class="cx"> LValue enumerator = lowCell(m_node->child1());
</span><span class="cx"> LValue index = lowInt32(m_node->child2());
</span><span class="cx">
</span><del>- LBasicBlock inBounds = FTL_NEW_BLOCK(m_out, ("GetEnumeratorGenericPname in bounds"));
- LBasicBlock outOfBounds = FTL_NEW_BLOCK(m_out, ("GetEnumeratorGenericPname out of bounds"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("GetEnumeratorGenericPname continuation"));
</del><ins>+ LBasicBlock inBounds = m_out.newBlock();
+ LBasicBlock outOfBounds = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(m_out.below(index, m_out.load32(enumerator, m_heaps.JSPropertyNameEnumerator_endGenericPropertyIndex)),
</span><span class="cx"> usually(inBounds), rarely(outOfBounds));
</span><span class="lines">@@ -6278,9 +6278,9 @@
</span><span class="cx">
</span><span class="cx"> Vector<LBasicBlock, 1> blocks(set.size());
</span><span class="cx"> for (unsigned i = set.size(); i--;)
</span><del>- blocks[i] = FTL_NEW_BLOCK(m_out, ("MaterializeNewObject case ", i));
- LBasicBlock dummyDefault = FTL_NEW_BLOCK(m_out, ("MaterializeNewObject default case"));
- LBasicBlock outerContinuation = FTL_NEW_BLOCK(m_out, ("MaterializeNewObject continuation"));
</del><ins>+ blocks[i] = m_out.newBlock();
+ LBasicBlock dummyDefault = m_out.newBlock();
+ LBasicBlock outerContinuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> Vector<SwitchCase, 1> cases(set.size());
</span><span class="cx"> for (unsigned i = set.size(); i--;)
</span><span class="lines">@@ -6304,8 +6304,8 @@
</span><span class="cx"> size_t allocationSize = JSFinalObject::allocationSize(structure->inlineCapacity());
</span><span class="cx"> MarkedAllocator* allocator = &vm().heap.allocatorForObjectWithoutDestructor(allocationSize);
</span><span class="cx">
</span><del>- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("MaterializeNewObject complex object allocation slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("MaterializeNewObject complex object allocation continuation"));
</del><ins>+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.insertNewBlocksBefore(slowPath);
</span><span class="cx">
</span><span class="lines">@@ -6384,8 +6384,8 @@
</span><span class="cx"> ASSERT(table == m_graph.varArgChild(m_node, 0)->castConstant<SymbolTable*>());
</span><span class="cx"> Structure* structure = m_graph.globalObjectFor(m_node->origin.semantic)->activationStructure();
</span><span class="cx">
</span><del>- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("MaterializeCreateActivation slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("MaterializeCreateActivation continuation"));
</del><ins>+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.insertNewBlocksBefore(slowPath);
</span><span class="cx">
</span><span class="lines">@@ -6445,8 +6445,8 @@
</span><span class="cx">
</span><span class="cx"> void compileCheckWatchdogTimer()
</span><span class="cx"> {
</span><del>- LBasicBlock timerDidFire = FTL_NEW_BLOCK(m_out, ("CheckWatchdogTimer timer did fire"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("CheckWatchdogTimer continuation"));
</del><ins>+ LBasicBlock timerDidFire = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue state = m_out.load8ZeroExt32(m_out.absolute(vm().watchdog()->timerDidFireAddress()));
</span><span class="cx"> m_out.branch(m_out.isZero32(state),
</span><span class="lines">@@ -6712,11 +6712,11 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("checkStructure continuation"));
</del><ins>+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.insertNewBlocksBefore(continuation);
</span><span class="cx"> for (unsigned i = 0; i < set.size() - 1; ++i) {
</span><del>- LBasicBlock nextStructure = FTL_NEW_BLOCK(m_out, ("checkStructure nextStructure"));
</del><ins>+ LBasicBlock nextStructure = m_out.newBlock();
</ins><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.equal(structureDiscriminant, weakStructureDiscriminant(set[i])),
</span><span class="cx"> unsure(continuation), unsure(nextStructure));
</span><span class="lines">@@ -6733,15 +6733,15 @@
</span><span class="cx">
</span><span class="cx"> LValue numberOrNotCellToInt32(Edge edge, LValue value)
</span><span class="cx"> {
</span><del>- LBasicBlock intCase = FTL_NEW_BLOCK(m_out, ("ValueToInt32 int case"));
- LBasicBlock notIntCase = FTL_NEW_BLOCK(m_out, ("ValueToInt32 not int case"));
</del><ins>+ LBasicBlock intCase = m_out.newBlock();
+ LBasicBlock notIntCase = m_out.newBlock();
</ins><span class="cx"> LBasicBlock doubleCase = 0;
</span><span class="cx"> LBasicBlock notNumberCase = 0;
</span><span class="cx"> if (edge.useKind() == NotCellUse) {
</span><del>- doubleCase = FTL_NEW_BLOCK(m_out, ("ValueToInt32 double case"));
- notNumberCase = FTL_NEW_BLOCK(m_out, ("ValueToInt32 not number case"));
</del><ins>+ doubleCase = m_out.newBlock();
+ notNumberCase = m_out.newBlock();
</ins><span class="cx"> }
</span><del>- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ValueToInt32 continuation"));
</del><ins>+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> Vector<ValueFromBlock> results;
</span><span class="cx">
</span><span class="lines">@@ -6845,9 +6845,9 @@
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> case InferredType::ObjectWithStructureOrOther: {
</span><del>- LBasicBlock cellCase = FTL_NEW_BLOCK(m_out, ("checkInferredType ObjectWithStructureOrOther cell case"));
- LBasicBlock notCellCase = FTL_NEW_BLOCK(m_out, ("checkInferredType ObjectWithStructureOrOther not cell case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("checkInferredType ObjectWithStructureOrOther continuation"));
</del><ins>+ LBasicBlock cellCase = m_out.newBlock();
+ LBasicBlock notCellCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(isCell(value, provenType(edge)), unsure(cellCase), unsure(notCellCase));
</span><span class="cx">
</span><span class="lines">@@ -6881,9 +6881,9 @@
</span><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> case InferredType::ObjectOrOther: {
</span><del>- LBasicBlock cellCase = FTL_NEW_BLOCK(m_out, ("checkInferredType ObjectOrOther cell case"));
- LBasicBlock notCellCase = FTL_NEW_BLOCK(m_out, ("checkInferredType ObjectOrOther not cell case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("checkInferredType ObjectOrOther continuation"));
</del><ins>+ LBasicBlock cellCase = m_out.newBlock();
+ LBasicBlock notCellCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(isCell(value, provenType(edge)), unsure(cellCase), unsure(notCellCase));
</span><span class="cx">
</span><span class="lines">@@ -7002,8 +7002,8 @@
</span><span class="cx">
</span><span class="cx"> LValue allocatePropertyStorageWithSizeImpl(size_t sizeInValues)
</span><span class="cx"> {
</span><del>- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("allocatePropertyStorageWithSizeImpl slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("allocatePropertyStorageWithSizeImpl continuation"));
</del><ins>+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.insertNewBlocksBefore(slowPath);
</span><span class="cx">
</span><span class="lines">@@ -7122,8 +7122,8 @@
</span><span class="cx"> return copyBarrier(
</span><span class="cx"> fastResultValue,
</span><span class="cx"> [&] () -> LValue {
</span><del>- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("loadVectorWithBarrier slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("loadVectorWithBarrier continuation"));
</del><ins>+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> ValueFromBlock fastResult = m_out.anchor(fastResultValue);
</span><span class="cx"> m_out.branch(isFastTypedArray(object), rarely(slowPath), usually(continuation));
</span><span class="lines">@@ -7160,8 +7160,8 @@
</span><span class="cx"> template<typename Functor>
</span><span class="cx"> LValue copyBarrier(LValue pointer, const Functor& functor)
</span><span class="cx"> {
</span><del>- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("copyBarrier slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("copyBarrier continuation"));
</del><ins>+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> ValueFromBlock fastResult = m_out.anchor(pointer);
</span><span class="cx"> m_out.branch(isInToSpace(pointer), usually(continuation), rarely(slowPath));
</span><span class="lines">@@ -7189,8 +7189,8 @@
</span><span class="cx"> {
</span><span class="cx"> LValue fastResultValue = m_out.loadPtr(object, m_heaps.JSArrayBufferView_vector);
</span><span class="cx">
</span><del>- LBasicBlock possiblyFromSpace = FTL_NEW_BLOCK(m_out, ("loadVectorReadOnly possibly from space"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("loadVectorReadOnly continuation"));
</del><ins>+ LBasicBlock possiblyFromSpace = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> ValueFromBlock fastResult = m_out.anchor(fastResultValue);
</span><span class="cx">
</span><span class="lines">@@ -7269,9 +7269,9 @@
</span><span class="cx">
</span><span class="cx"> speculateTruthyObject(rightChild, rightCell, SpecObject);
</span><span class="cx">
</span><del>- LBasicBlock leftCellCase = FTL_NEW_BLOCK(m_out, ("CompareEqObjectOrOtherToObject left cell case"));
- LBasicBlock leftNotCellCase = FTL_NEW_BLOCK(m_out, ("CompareEqObjectOrOtherToObject left not cell case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("CompareEqObjectOrOtherToObject continuation"));
</del><ins>+ LBasicBlock leftCellCase = m_out.newBlock();
+ LBasicBlock leftNotCellCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> isCell(leftValue, provenType(leftChild)),
</span><span class="lines">@@ -7313,10 +7313,10 @@
</span><span class="cx"> LValue left = lowJSValue(m_node->child1());
</span><span class="cx"> LValue right = lowJSValue(m_node->child2());
</span><span class="cx">
</span><del>- LBasicBlock leftIsInt = FTL_NEW_BLOCK(m_out, ("CompareEq untyped left is int"));
- LBasicBlock fastPath = FTL_NEW_BLOCK(m_out, ("CompareEq untyped fast path"));
- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("CompareEq untyped slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("CompareEq untyped continuation"));
</del><ins>+ LBasicBlock leftIsInt = m_out.newBlock();
+ LBasicBlock fastPath = m_out.newBlock();
+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(isNotInt32(left), rarely(slowPath), usually(leftIsInt));
</span><span class="cx">
</span><span class="lines">@@ -7338,18 +7338,18 @@
</span><span class="cx">
</span><span class="cx"> LValue stringsEqual(LValue leftJSString, LValue rightJSString)
</span><span class="cx"> {
</span><del>- LBasicBlock notTriviallyUnequalCase = FTL_NEW_BLOCK(m_out, ("stringsEqual not trivially unequal case"));
- LBasicBlock notEmptyCase = FTL_NEW_BLOCK(m_out, ("stringsEqual not empty case"));
- LBasicBlock leftReadyCase = FTL_NEW_BLOCK(m_out, ("stringsEqual left ready case"));
- LBasicBlock rightReadyCase = FTL_NEW_BLOCK(m_out, ("stringsEqual right ready case"));
- LBasicBlock left8BitCase = FTL_NEW_BLOCK(m_out, ("stringsEqual left 8-bit case"));
- LBasicBlock right8BitCase = FTL_NEW_BLOCK(m_out, ("stringsEqual right 8-bit case"));
- LBasicBlock loop = FTL_NEW_BLOCK(m_out, ("stringsEqual loop"));
- LBasicBlock bytesEqual = FTL_NEW_BLOCK(m_out, ("stringsEqual bytes equal"));
- LBasicBlock trueCase = FTL_NEW_BLOCK(m_out, ("stringsEqual true case"));
- LBasicBlock falseCase = FTL_NEW_BLOCK(m_out, ("stringsEqual false case"));
- LBasicBlock slowCase = FTL_NEW_BLOCK(m_out, ("stringsEqual slow case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("stringsEqual continuation"));
</del><ins>+ LBasicBlock notTriviallyUnequalCase = m_out.newBlock();
+ LBasicBlock notEmptyCase = m_out.newBlock();
+ LBasicBlock leftReadyCase = m_out.newBlock();
+ LBasicBlock rightReadyCase = m_out.newBlock();
+ LBasicBlock left8BitCase = m_out.newBlock();
+ LBasicBlock right8BitCase = m_out.newBlock();
+ LBasicBlock loop = m_out.newBlock();
+ LBasicBlock bytesEqual = m_out.newBlock();
+ LBasicBlock trueCase = m_out.newBlock();
+ LBasicBlock falseCase = m_out.newBlock();
+ LBasicBlock slowCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue length = m_out.load32(leftJSString, m_heaps.JSString_length);
</span><span class="cx">
</span><span class="lines">@@ -7624,7 +7624,7 @@
</span><span class="cx">
</span><span class="cx"> LValue allocateCell(LValue allocator, LBasicBlock slowPath)
</span><span class="cx"> {
</span><del>- LBasicBlock success = FTL_NEW_BLOCK(m_out, ("object allocation success"));
</del><ins>+ LBasicBlock success = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue result;
</span><span class="cx"> LValue condition;
</span><span class="lines">@@ -7694,10 +7694,10 @@
</span><span class="cx">
</span><span class="cx"> LValue subspace = m_out.constIntPtr(&vm().heap.subspaceForObjectOfType<ClassType>());
</span><span class="cx">
</span><del>- LBasicBlock smallCaseBlock = FTL_NEW_BLOCK(m_out, ("allocateVariableSizedObject small case"));
- LBasicBlock largeOrOversizeCaseBlock = FTL_NEW_BLOCK(m_out, ("allocateVariableSizedObject large or oversize case"));
- LBasicBlock largeCaseBlock = FTL_NEW_BLOCK(m_out, ("allocateVariableSizedObject large case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("allocateVariableSizedObject continuation"));
</del><ins>+ LBasicBlock smallCaseBlock = m_out.newBlock();
+ LBasicBlock largeOrOversizeCaseBlock = m_out.newBlock();
+ LBasicBlock largeCaseBlock = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue uproundedSize = m_out.add(size, m_out.constInt32(MarkedSpace::preciseStep - 1));
</span><span class="cx"> LValue isSmall = m_out.below(uproundedSize, m_out.constInt32(MarkedSpace::preciseCutoff));
</span><span class="lines">@@ -7733,7 +7733,7 @@
</span><span class="cx"> {
</span><span class="cx"> CopiedAllocator& allocator = vm().heap.storageAllocator();
</span><span class="cx">
</span><del>- LBasicBlock success = FTL_NEW_BLOCK(m_out, ("storage allocation success"));
</del><ins>+ LBasicBlock success = m_out.newBlock();
</ins><span class="cx">
</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="lines">@@ -7759,8 +7759,8 @@
</span><span class="cx"> size_t allocationSize = JSFinalObject::allocationSize(structure->inlineCapacity());
</span><span class="cx"> MarkedAllocator* allocator = &vm().heap.allocatorForObjectWithoutDestructor(allocationSize);
</span><span class="cx">
</span><del>- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("allocateObject slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("allocateObject continuation"));
</del><ins>+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.insertNewBlocksBefore(slowPath);
</span><span class="cx">
</span><span class="lines">@@ -7837,8 +7837,8 @@
</span><span class="cx">
</span><span class="cx"> ArrayValues allocateJSArray(Structure* structure, unsigned numElements)
</span><span class="cx"> {
</span><del>- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("JSArray allocation slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("JSArray allocation continuation"));
</del><ins>+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.insertNewBlocksBefore(slowPath);
</span><span class="cx">
</span><span class="lines">@@ -7889,6 +7889,31 @@
</span><span class="cx"> LValue length = m_out.load32NonNegative(stringValue, m_heaps.JSString_length);
</span><span class="cx"> return m_out.notEqual(length, m_out.int32Zero);
</span><span class="cx"> }
</span><ins>+ case StringOrOtherUse: {
+ LValue value = lowJSValue(edge, ManualOperandSpeculation);
+
+ LBasicBlock cellCase = m_out.newBlock();
+ LBasicBlock notCellCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
+
+ m_out.branch(isCell(value, provenType(edge)), unsure(cellCase), unsure(notCellCase));
+
+ LBasicBlock lastNext = m_out.appendTo(cellCase, notCellCase);
+
+ FTL_TYPE_CHECK(jsValueValue(value), edge, (~SpecCell) | SpecString, isNotString(value));
+ LValue length = m_out.load32NonNegative(value, m_heaps.JSString_length);
+ ValueFromBlock cellResult = m_out.anchor(m_out.notEqual(length, m_out.int32Zero));
+ m_out.jump(continuation);
+
+ m_out.appendTo(notCellCase, continuation);
+
+ FTL_TYPE_CHECK(jsValueValue(value), edge, SpecCell | SpecOther, isNotOther(value));
+ ValueFromBlock notCellResult = m_out.anchor(m_out.booleanFalse);
+ m_out.jump(continuation);
+ m_out.appendTo(continuation, lastNext);
+
+ return m_out.phi(Int32, cellResult, notCellResult);
+ }
</ins><span class="cx"> case UntypedUse: {
</span><span class="cx"> LValue value = lowJSValue(edge);
</span><span class="cx">
</span><span class="lines">@@ -7908,15 +7933,15 @@
</span><span class="cx"> // result = value == jsTrue
</span><span class="cx"> // }
</span><span class="cx">
</span><del>- LBasicBlock cellCase = FTL_NEW_BLOCK(m_out, ("Boolify untyped cell case"));
- LBasicBlock stringCase = FTL_NEW_BLOCK(m_out, ("Boolify untyped string case"));
- LBasicBlock notStringCase = FTL_NEW_BLOCK(m_out, ("Boolify untyped not string case"));
- LBasicBlock notCellCase = FTL_NEW_BLOCK(m_out, ("Boolify untyped not cell case"));
- LBasicBlock int32Case = FTL_NEW_BLOCK(m_out, ("Boolify untyped int32 case"));
- LBasicBlock notInt32Case = FTL_NEW_BLOCK(m_out, ("Boolify untyped not int32 case"));
- LBasicBlock doubleCase = FTL_NEW_BLOCK(m_out, ("Boolify untyped double case"));
- LBasicBlock notDoubleCase = FTL_NEW_BLOCK(m_out, ("Boolify untyped not double case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("Boolify untyped continuation"));
</del><ins>+ LBasicBlock cellCase = m_out.newBlock();
+ LBasicBlock stringCase = m_out.newBlock();
+ LBasicBlock notStringCase = m_out.newBlock();
+ LBasicBlock notCellCase = m_out.newBlock();
+ LBasicBlock int32Case = m_out.newBlock();
+ LBasicBlock notInt32Case = m_out.newBlock();
+ LBasicBlock doubleCase = m_out.newBlock();
+ LBasicBlock notDoubleCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> Vector<ValueFromBlock> results;
</span><span class="cx">
</span><span class="lines">@@ -7938,7 +7963,7 @@
</span><span class="cx"> if (masqueradesAsUndefinedWatchpointIsStillValid())
</span><span class="cx"> isTruthyObject = m_out.booleanTrue;
</span><span class="cx"> else {
</span><del>- LBasicBlock masqueradesCase = FTL_NEW_BLOCK(m_out, ("Boolify untyped masquerades case"));
</del><ins>+ LBasicBlock masqueradesCase = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> results.append(m_out.anchor(m_out.booleanTrue));
</span><span class="cx">
</span><span class="lines">@@ -8010,9 +8035,9 @@
</span><span class="cx">
</span><span class="cx"> LValue value = lowJSValue(edge, operandMode);
</span><span class="cx">
</span><del>- LBasicBlock cellCase = FTL_NEW_BLOCK(m_out, ("EqualNullOrUndefined cell case"));
- LBasicBlock primitiveCase = FTL_NEW_BLOCK(m_out, ("EqualNullOrUndefined primitive case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("EqualNullOrUndefined continuation"));
</del><ins>+ LBasicBlock cellCase = m_out.newBlock();
+ LBasicBlock primitiveCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(isNotCell(value, provenType(edge)), unsure(primitiveCase), unsure(cellCase));
</span><span class="cx">
</span><span class="lines">@@ -8034,7 +8059,7 @@
</span><span class="cx"> m_out.jump(continuation);
</span><span class="cx"> } else {
</span><span class="cx"> LBasicBlock masqueradesCase =
</span><del>- FTL_NEW_BLOCK(m_out, ("EqualNullOrUndefined masquerades case"));
</del><ins>+ m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> results.append(m_out.anchor(m_out.booleanFalse));
</span><span class="cx">
</span><span class="lines">@@ -8091,9 +8116,9 @@
</span><span class="cx"> index, m_out.load32NonNegative(storage, m_heaps.Butterfly_publicLength));
</span><span class="cx"> if (!m_node->arrayMode().isInBounds()) {
</span><span class="cx"> LBasicBlock notInBoundsCase =
</span><del>- FTL_NEW_BLOCK(m_out, ("PutByVal not in bounds"));
</del><ins>+ m_out.newBlock();
</ins><span class="cx"> LBasicBlock performStore =
</span><del>- FTL_NEW_BLOCK(m_out, ("PutByVal perform store"));
</del><ins>+ m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(isNotInBounds, unsure(notInBoundsCase), unsure(performStore));
</span><span class="cx">
</span><span class="lines">@@ -8106,9 +8131,9 @@
</span><span class="cx"> speculate(OutOfBounds, noValue(), 0, isOutOfBounds);
</span><span class="cx"> else {
</span><span class="cx"> LBasicBlock outOfBoundsCase =
</span><del>- FTL_NEW_BLOCK(m_out, ("PutByVal out of bounds"));
</del><ins>+ m_out.newBlock();
</ins><span class="cx"> LBasicBlock holeCase =
</span><del>- FTL_NEW_BLOCK(m_out, ("PutByVal hole case"));
</del><ins>+ m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(isOutOfBounds, rarely(outOfBoundsCase), usually(holeCase));
</span><span class="cx">
</span><span class="lines">@@ -8183,9 +8208,9 @@
</span><span class="cx"> LValue stringImpl = m_out.loadPtr(string, m_heaps.JSString_value);
</span><span class="cx"> LValue length = m_out.load32(string, m_heaps.JSString_length);
</span><span class="cx">
</span><del>- LBasicBlock hasImplBlock = FTL_NEW_BLOCK(m_out, ("Switch/SwitchString has impl case"));
- LBasicBlock is8BitBlock = FTL_NEW_BLOCK(m_out, ("Switch/SwitchString is 8 bit case"));
- LBasicBlock slowBlock = FTL_NEW_BLOCK(m_out, ("Switch/SwitchString slow case"));
</del><ins>+ LBasicBlock hasImplBlock = m_out.newBlock();
+ LBasicBlock is8BitBlock = m_out.newBlock();
+ LBasicBlock slowBlock = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(m_out.isNull(stringImpl), unsure(slowBlock), unsure(hasImplBlock));
</span><span class="cx">
</span><span class="lines">@@ -8360,8 +8385,8 @@
</span><span class="cx"> characterCases.append(currentCase);
</span><span class="cx">
</span><span class="cx"> Vector<LBasicBlock> characterBlocks;
</span><del>- for (CharacterCase& myCase : characterCases)
- characterBlocks.append(FTL_NEW_BLOCK(m_out, ("Switch/SwitchString case for ", myCase.character, " at index ", commonChars)));
</del><ins>+ for (unsigned i = characterCases.size(); i--;)
+ characterBlocks.append(m_out.newBlock());
</ins><span class="cx">
</span><span class="cx"> Vector<SwitchCase> switchCases;
</span><span class="cx"> for (unsigned i = 0; i < characterCases.size(); ++i) {
</span><span class="lines">@@ -8455,7 +8480,7 @@
</span><span class="cx"> // contination and set it as the nextBlock (m_out.insertNewBlocksBefore(continuation)) before
</span><span class="cx"> // calling this. For example:
</span><span class="cx"> //
</span><del>- // LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("My continuation"));
</del><ins>+ // LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx"> // LBasicBlock lastNext = m_out.insertNewBlocksBefore(continuation);
</span><span class="cx"> // buildTypeOf(
</span><span class="cx"> // child, value,
</span><span class="lines">@@ -8495,22 +8520,22 @@
</span><span class="cx"> // return undefined
</span><span class="cx"> // }
</span><span class="cx">
</span><del>- LBasicBlock cellCase = FTL_NEW_BLOCK(m_out, ("buildTypeOf cell case"));
- LBasicBlock objectCase = FTL_NEW_BLOCK(m_out, ("buildTypeOf object case"));
- LBasicBlock functionCase = FTL_NEW_BLOCK(m_out, ("buildTypeOf function case"));
- LBasicBlock notFunctionCase = FTL_NEW_BLOCK(m_out, ("buildTypeOf not function case"));
- LBasicBlock reallyObjectCase = FTL_NEW_BLOCK(m_out, ("buildTypeOf really object case"));
- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("buildTypeOf slow path"));
- LBasicBlock unreachable = FTL_NEW_BLOCK(m_out, ("buildTypeOf unreachable"));
- LBasicBlock notObjectCase = FTL_NEW_BLOCK(m_out, ("buildTypeOf not object case"));
- LBasicBlock stringCase = FTL_NEW_BLOCK(m_out, ("buildTypeOf string case"));
- LBasicBlock symbolCase = FTL_NEW_BLOCK(m_out, ("buildTypeOf symbol case"));
- LBasicBlock notCellCase = FTL_NEW_BLOCK(m_out, ("buildTypeOf not cell case"));
- LBasicBlock numberCase = FTL_NEW_BLOCK(m_out, ("buildTypeOf number case"));
- LBasicBlock notNumberCase = FTL_NEW_BLOCK(m_out, ("buildTypeOf not number case"));
- LBasicBlock notNullCase = FTL_NEW_BLOCK(m_out, ("buildTypeOf not null case"));
- LBasicBlock booleanCase = FTL_NEW_BLOCK(m_out, ("buildTypeOf boolean case"));
- LBasicBlock undefinedCase = FTL_NEW_BLOCK(m_out, ("buildTypeOf undefined case"));
</del><ins>+ LBasicBlock cellCase = m_out.newBlock();
+ LBasicBlock objectCase = m_out.newBlock();
+ LBasicBlock functionCase = m_out.newBlock();
+ LBasicBlock notFunctionCase = m_out.newBlock();
+ LBasicBlock reallyObjectCase = m_out.newBlock();
+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock unreachable = m_out.newBlock();
+ LBasicBlock notObjectCase = m_out.newBlock();
+ LBasicBlock stringCase = m_out.newBlock();
+ LBasicBlock symbolCase = m_out.newBlock();
+ LBasicBlock notCellCase = m_out.newBlock();
+ LBasicBlock numberCase = m_out.newBlock();
+ LBasicBlock notNumberCase = m_out.newBlock();
+ LBasicBlock notNullCase = m_out.newBlock();
+ LBasicBlock booleanCase = m_out.newBlock();
+ LBasicBlock undefinedCase = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(isCell(value, provenType(child)), unsure(cellCase), unsure(notCellCase));
</span><span class="cx">
</span><span class="lines">@@ -8590,10 +8615,10 @@
</span><span class="cx">
</span><span class="cx"> LValue doubleToInt32(LValue doubleValue, double low, double high, bool isSigned = true)
</span><span class="cx"> {
</span><del>- LBasicBlock greatEnough = FTL_NEW_BLOCK(m_out, ("doubleToInt32 greatEnough"));
- LBasicBlock withinRange = FTL_NEW_BLOCK(m_out, ("doubleToInt32 withinRange"));
- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("doubleToInt32 slowPath"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("doubleToInt32 continuation"));
</del><ins>+ LBasicBlock greatEnough = m_out.newBlock();
+ LBasicBlock withinRange = m_out.newBlock();
+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> Vector<ValueFromBlock, 2> results;
</span><span class="cx">
</span><span class="lines">@@ -8634,8 +8659,8 @@
</span><span class="cx">
</span><span class="cx"> LValue sensibleDoubleToInt32(LValue doubleValue)
</span><span class="cx"> {
</span><del>- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("sensible doubleToInt32 slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("sensible doubleToInt32 continuation"));
</del><ins>+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue fastResultValue = m_out.doubleToInt(doubleValue);
</span><span class="cx"> ValueFromBlock fastResult = m_out.anchor(fastResultValue);
</span><span class="lines">@@ -9149,9 +9174,9 @@
</span><span class="cx">
</span><span class="cx"> LValue strictInt52ToJSValue(LValue value)
</span><span class="cx"> {
</span><del>- LBasicBlock isInt32 = FTL_NEW_BLOCK(m_out, ("strictInt52ToJSValue isInt32 case"));
- LBasicBlock isDouble = FTL_NEW_BLOCK(m_out, ("strictInt52ToJSValue isDouble case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("strictInt52ToJSValue continuation"));
</del><ins>+ LBasicBlock isInt32 = m_out.newBlock();
+ LBasicBlock isDouble = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> Vector<ValueFromBlock, 2> results;
</span><span class="cx">
</span><span class="lines">@@ -9229,9 +9254,9 @@
</span><span class="cx">
</span><span class="cx"> LValue jsValueToStrictInt52(Edge edge, LValue boxedValue)
</span><span class="cx"> {
</span><del>- LBasicBlock intCase = FTL_NEW_BLOCK(m_out, ("jsValueToInt52 unboxing int case"));
- LBasicBlock doubleCase = FTL_NEW_BLOCK(m_out, ("jsValueToInt52 unboxing double case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("jsValueToInt52 unboxing continuation"));
</del><ins>+ LBasicBlock intCase = m_out.newBlock();
+ LBasicBlock doubleCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue isNotInt32;
</span><span class="cx"> if (!m_interpreter.needsTypeCheck(edge, SpecInt32))
</span><span class="lines">@@ -9283,8 +9308,8 @@
</span><span class="cx"> speculate(Overflow, FormattedValue(DataFormatDouble, value), m_node, valueNotConvertibleToInteger);
</span><span class="cx">
</span><span class="cx"> if (shouldCheckNegativeZero) {
</span><del>- LBasicBlock valueIsZero = FTL_NEW_BLOCK(m_out, ("ConvertDoubleToInt32 on zero"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("ConvertDoubleToInt32 continuation"));
</del><ins>+ LBasicBlock valueIsZero = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx"> m_out.branch(m_out.isZero32(integerValue), unsure(valueIsZero), unsure(continuation));
</span><span class="cx">
</span><span class="cx"> LBasicBlock lastNext = m_out.appendTo(valueIsZero, continuation);
</span><span class="lines">@@ -9437,6 +9462,9 @@
</span><span class="cx"> case StringUse:
</span><span class="cx"> speculateString(edge);
</span><span class="cx"> break;
</span><ins>+ case StringOrOtherUse:
+ speculateStringOrOther(edge);
+ break;
</ins><span class="cx"> case StringIdentUse:
</span><span class="cx"> speculateStringIdent(edge);
</span><span class="cx"> break;
</span><span class="lines">@@ -9500,8 +9528,8 @@
</span><span class="cx"> {
</span><span class="cx"> LValue value = lowJSValue(edge, ManualOperandSpeculation);
</span><span class="cx">
</span><del>- LBasicBlock isNotCell = FTL_NEW_BLOCK(m_out, ("Speculate CellOrOther not cell"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("Speculate CellOrOther continuation"));
</del><ins>+ LBasicBlock isNotCell = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(isCell(value, provenType(edge)), unsure(continuation), unsure(isNotCell));
</span><span class="cx">
</span><span class="lines">@@ -9676,9 +9704,9 @@
</span><span class="cx">
</span><span class="cx"> LValue value = lowJSValue(edge, ManualOperandSpeculation);
</span><span class="cx">
</span><del>- LBasicBlock cellCase = FTL_NEW_BLOCK(m_out, ("speculateObjectOrOther cell case"));
- LBasicBlock primitiveCase = FTL_NEW_BLOCK(m_out, ("speculateObjectOrOther primitive case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("speculateObjectOrOther continuation"));
</del><ins>+ LBasicBlock cellCase = m_out.newBlock();
+ LBasicBlock primitiveCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(isNotCell(value, provenType(edge)), unsure(primitiveCase), unsure(cellCase));
</span><span class="cx">
</span><span class="lines">@@ -9731,6 +9759,32 @@
</span><span class="cx"> speculateString(edge, lowCell(edge));
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+ void speculateStringOrOther(Edge edge, LValue value)
+ {
+ LBasicBlock cellCase = m_out.newBlock();
+ LBasicBlock notCellCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
+
+ m_out.branch(isCell(value, provenType(edge)), unsure(cellCase), unsure(notCellCase));
+
+ LBasicBlock lastNext = m_out.appendTo(cellCase, notCellCase);
+
+ FTL_TYPE_CHECK(jsValueValue(value), edge, (~SpecCell) | SpecString, isNotString(value));
+
+ m_out.jump(continuation);
+ m_out.appendTo(notCellCase, continuation);
+
+ FTL_TYPE_CHECK(jsValueValue(value), edge, SpecCell | SpecOther, isNotOther(value));
+
+ m_out.jump(continuation);
+ m_out.appendTo(continuation, lastNext);
+ }
+
+ void speculateStringOrOther(Edge edge)
+ {
+ speculateStringOrOther(edge, lowJSValue(edge, ManualOperandSpeculation));
+ }
+
</ins><span class="cx"> void speculateStringIdent(Edge edge, LValue string, LValue stringImpl)
</span><span class="cx"> {
</span><span class="cx"> if (!m_interpreter.needsTypeCheck(edge, SpecStringIdent | ~SpecString))
</span><span class="lines">@@ -9764,8 +9818,8 @@
</span><span class="cx"> if (!m_interpreter.needsTypeCheck(edge, SpecString | SpecStringObject))
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- LBasicBlock notString = FTL_NEW_BLOCK(m_out, ("Speculate StringOrStringObject not string case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("Speculate StringOrStringObject continuation"));
</del><ins>+ LBasicBlock notString = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> LValue structureID = m_out.load32(lowCell(edge), m_heaps.JSCell_structureID);
</span><span class="cx"> m_out.branch(
</span><span class="lines">@@ -9837,8 +9891,8 @@
</span><span class="cx"> LValue value = lowJSValue(edge, ManualOperandSpeculation);
</span><span class="cx"> LValue doubleValue = unboxDouble(value);
</span><span class="cx">
</span><del>- LBasicBlock intCase = FTL_NEW_BLOCK(m_out, ("speculateRealNumber int case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("speculateRealNumber continuation"));
</del><ins>+ LBasicBlock intCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.doubleEqual(doubleValue, doubleValue),
</span><span class="lines">@@ -9886,9 +9940,9 @@
</span><span class="cx">
</span><span class="cx"> LValue value = lowJSValue(edge, ManualOperandSpeculation);
</span><span class="cx">
</span><del>- LBasicBlock isCellCase = FTL_NEW_BLOCK(m_out, ("Speculate NotStringVar is cell case"));
- LBasicBlock isStringCase = FTL_NEW_BLOCK(m_out, ("Speculate NotStringVar is string case"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("Speculate NotStringVar continuation"));
</del><ins>+ LBasicBlock isCellCase = m_out.newBlock();
+ LBasicBlock isStringCase = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(isCell(value, provenType(edge)), unsure(isCellCase), unsure(continuation));
</span><span class="cx">
</span><span class="lines">@@ -9941,8 +9995,8 @@
</span><span class="cx">
</span><span class="cx"> void emitStoreBarrier(LValue base)
</span><span class="cx"> {
</span><del>- LBasicBlock slowPath = FTL_NEW_BLOCK(m_out, ("Store barrier slow path"));
- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("Store barrier continuation"));
</del><ins>+ LBasicBlock slowPath = m_out.newBlock();
+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> m_out.notZero32(loadCellState(base)), usually(continuation), rarely(slowPath));
</span><span class="lines">@@ -10065,7 +10119,7 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- LBasicBlock continuation = FTL_NEW_BLOCK(m_out, ("Exception check continuation"));
</del><ins>+ LBasicBlock continuation = m_out.newBlock();
</ins><span class="cx">
</span><span class="cx"> m_out.branch(
</span><span class="cx"> hadException, rarely(m_handleExceptions), usually(continuation));
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLOutputcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLOutput.cpp (197648 => 197649)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLOutput.cpp 2016-03-07 01:00:33 UTC (rev 197648)
+++ trunk/Source/JavaScriptCore/ftl/FTLOutput.cpp 2016-03-07 02:07:28 UTC (rev 197649)
</span><span class="lines">@@ -49,7 +49,7 @@
</span><span class="cx"> m_heaps = &heaps;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-LBasicBlock Output::newBlock(const char*)
</del><ins>+LBasicBlock Output::newBlock()
</ins><span class="cx"> {
</span><span class="cx"> LBasicBlock result = m_proc.addBlock(m_frequency);
</span><span class="cx">
</span><span class="lines">@@ -232,7 +232,7 @@
</span><span class="cx">
</span><span class="cx"> void Output::check(LValue condition, WeightedTarget taken, Weight notTakenWeight)
</span><span class="cx"> {
</span><del>- LBasicBlock continuation = FTL_NEW_BLOCK(*this, ("Output::check continuation"));
</del><ins>+ LBasicBlock continuation = newBlock();
</ins><span class="cx"> branch(condition, taken, WeightedTarget(continuation, notTakenWeight));
</span><span class="cx"> appendTo(continuation);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLOutputh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLOutput.h (197648 => 197649)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLOutput.h 2016-03-07 01:00:33 UTC (rev 197648)
+++ trunk/Source/JavaScriptCore/ftl/FTLOutput.h 2016-03-07 02:07:28 UTC (rev 197649)
</span><span class="lines">@@ -82,7 +82,7 @@
</span><span class="cx"> m_frequency = value;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- LBasicBlock newBlock(const char* name = "");
</del><ins>+ LBasicBlock newBlock();
</ins><span class="cx">
</span><span class="cx"> LBasicBlock insertNewBlocksBefore(LBasicBlock nextBlock)
</span><span class="cx"> {
</span><span class="lines">@@ -524,11 +524,6 @@
</span><span class="cx"> #pragma GCC diagnostic pop
</span><span class="cx"> #endif // COMPILER(GCC_OR_CLANG)
</span><span class="cx">
</span><del>-#define FTL_NEW_BLOCK(output, nameArguments) \
- (LIKELY(!verboseCompilationEnabled()) \
- ? (output).newBlock() \
- : (output).newBlock((toCString nameArguments).data()))
-
</del><span class="cx"> } } // namespace JSC::FTL
</span><span class="cx">
</span><span class="cx"> #endif // ENABLE(FTL_JIT)
</span></span></pre>
</div>
</div>
</body>
</html>