<!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>[200034] 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/200034">200034</a></dd>
<dt>Author</dt> <dd>mark.lam@apple.com</dd>
<dt>Date</dt> <dd>2016-04-25 10:48:46 -0700 (Mon, 25 Apr 2016)</dd>
</dl>
<h3>Log Message</h3>
<pre>Renaming SpecInt32, SpecInt52, MachineInt to SpecInt32Only, SpecInt52Only, AnyInt.
https://bugs.webkit.org/show_bug.cgi?id=156941
Reviewed by Filip Pizlo.
While looking at https://bugs.webkit.org/show_bug.cgi?id=153431, it was decided
that SpecInt32Only, SpecInt52Only, and AnyInt would be better names for
SpecInt32, SpecInt52, and MachineInt. Let's do a bulk rename.
This is only a renaming patch, and deletion of a piece of unused code. There are
no semantic changes.
* bindings/ScriptValue.cpp:
(Inspector::jsToInspectorValue):
* bytecode/SpeculatedType.cpp:
(JSC::dumpSpeculation):
(JSC::speculationToAbbreviatedString):
(JSC::speculationFromValue):
(JSC::leastUpperBoundOfStrictlyEquivalentSpeculations):
(JSC::typeOfDoubleNegation):
(JSC::typeOfDoubleRounding):
* bytecode/SpeculatedType.h:
(JSC::isInt32Speculation):
(JSC::isInt32OrBooleanSpeculation):
(JSC::isInt32SpeculationForArithmetic):
(JSC::isInt32OrBooleanSpeculationForArithmetic):
(JSC::isInt32OrBooleanSpeculationExpectingDefined):
(JSC::isInt52Speculation):
(JSC::isAnyIntSpeculation):
(JSC::isAnyIntAsDoubleSpeculation):
(JSC::isDoubleRealSpeculation):
(JSC::isMachineIntSpeculation): Deleted.
(JSC::isInt52AsDoubleSpeculation): Deleted.
(JSC::isIntegerSpeculation): Deleted.
* dfg/DFGAbstractInterpreterInlines.h:
(JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
* dfg/DFGAbstractValue.cpp:
(JSC::DFG::AbstractValue::set):
(JSC::DFG::AbstractValue::fixTypeForRepresentation):
(JSC::DFG::AbstractValue::checkConsistency):
(JSC::DFG::AbstractValue::resultType):
* dfg/DFGAbstractValue.h:
(JSC::DFG::AbstractValue::validateType):
* dfg/DFGArgumentsUtilities.cpp:
(JSC::DFG::emitCodeToGetArgumentsArrayLength):
* dfg/DFGByteCodeParser.cpp:
(JSC::DFG::ByteCodeParser::handleInlining):
(JSC::DFG::ByteCodeParser::handleIntrinsicCall):
* dfg/DFGFixupPhase.cpp:
(JSC::DFG::FixupPhase::fixupNode):
(JSC::DFG::FixupPhase::fixupToThis):
(JSC::DFG::FixupPhase::observeUseKindOnNode):
(JSC::DFG::FixupPhase::fixIntConvertingEdge):
(JSC::DFG::FixupPhase::fixIntOrBooleanEdge):
(JSC::DFG::FixupPhase::fixDoubleOrBooleanEdge):
(JSC::DFG::FixupPhase::truncateConstantToInt32):
(JSC::DFG::FixupPhase::attemptToMakeIntegerAdd):
(JSC::DFG::FixupPhase::prependGetArrayLength):
(JSC::DFG::FixupPhase::fixupChecksInBlock):
* dfg/DFGGraph.h:
(JSC::DFG::Graph::addShouldSpeculateInt32):
(JSC::DFG::Graph::addShouldSpeculateAnyInt):
(JSC::DFG::Graph::binaryArithShouldSpeculateInt32):
(JSC::DFG::Graph::binaryArithShouldSpeculateAnyInt):
(JSC::DFG::Graph::unaryArithShouldSpeculateInt32):
(JSC::DFG::Graph::unaryArithShouldSpeculateAnyInt):
(JSC::DFG::Graph::addShouldSpeculateMachineInt): Deleted.
(JSC::DFG::Graph::binaryArithShouldSpeculateMachineInt): Deleted.
(JSC::DFG::Graph::unaryArithShouldSpeculateMachineInt): Deleted.
* dfg/DFGInPlaceAbstractState.cpp:
(JSC::DFG::InPlaceAbstractState::initialize):
* dfg/DFGJITCompiler.cpp:
(JSC::DFG::JITCompiler::noticeOSREntry):
* dfg/DFGNode.cpp:
(JSC::DFG::Node::convertToIdentityOn):
* dfg/DFGNode.h:
(JSC::DFG::Node::asNumber):
(JSC::DFG::Node::isAnyIntConstant):
(JSC::DFG::Node::asAnyInt):
(JSC::DFG::Node::isBooleanConstant):
(JSC::DFG::Node::shouldSpeculateInt32OrBooleanExpectingDefined):
(JSC::DFG::Node::shouldSpeculateAnyInt):
(JSC::DFG::Node::shouldSpeculateDouble):
(JSC::DFG::Node::shouldSpeculateNumber):
(JSC::DFG::Node::isMachineIntConstant): Deleted.
(JSC::DFG::Node::asMachineInt): Deleted.
(JSC::DFG::Node::shouldSpeculateMachineInt): Deleted.
* dfg/DFGOSREntry.cpp:
(JSC::DFG::OSREntryData::dumpInContext):
(JSC::DFG::prepareOSREntry):
* dfg/DFGOSREntry.h:
* dfg/DFGPredictionPropagationPhase.cpp:
* dfg/DFGSSALoweringPhase.cpp:
(JSC::DFG::SSALoweringPhase::handleNode):
(JSC::DFG::SSALoweringPhase::lowerBoundsCheck):
* dfg/DFGSafeToExecute.h:
(JSC::DFG::SafeToExecuteEdge::operator()):
* dfg/DFGSpeculativeJIT.cpp:
(JSC::DFG::SpeculativeJIT::silentFill):
(JSC::DFG::SpeculativeJIT::compileGetByValOnIntTypedArray):
(JSC::DFG::SpeculativeJIT::compileArithAdd):
(JSC::DFG::SpeculativeJIT::compileArithSub):
(JSC::DFG::SpeculativeJIT::compileArithNegate):
(JSC::DFG::SpeculativeJIT::speculateInt32):
(JSC::DFG::SpeculativeJIT::speculateNumber):
(JSC::DFG::SpeculativeJIT::speculateMisc):
(JSC::DFG::SpeculativeJIT::speculate):
* dfg/DFGSpeculativeJIT.h:
(JSC::DFG::SpeculativeJIT::spill):
(JSC::DFG::SpeculativeJIT::isKnownInteger):
(JSC::DFG::SpeculativeJIT::isKnownCell):
(JSC::DFG::SpeculativeJIT::isKnownNotInteger):
(JSC::DFG::SpeculativeJIT::isKnownNotNumber):
(JSC::DFG::SpeculativeJIT::isKnownNotCell):
(JSC::DFG::SpeculativeJIT::isKnownNotOther):
* dfg/DFGSpeculativeJIT32_64.cpp:
(JSC::DFG::SpeculativeJIT::fillSpeculateInt32Internal):
(JSC::DFG::SpeculativeJIT::compile):
* dfg/DFGSpeculativeJIT64.cpp:
(JSC::DFG::SpeculativeJIT::fillSpeculateInt32Internal):
(JSC::DFG::SpeculativeJIT::fillSpeculateInt52):
(JSC::DFG::SpeculativeJIT::fillSpeculateDouble):
(JSC::DFG::SpeculativeJIT::emitBranch):
(JSC::DFG::SpeculativeJIT::compile):
(JSC::DFG::SpeculativeJIT::blessBoolean):
(JSC::DFG::SpeculativeJIT::convertAnyInt):
(JSC::DFG::SpeculativeJIT::speculateAnyInt):
(JSC::DFG::SpeculativeJIT::speculateDoubleRepAnyInt):
(JSC::DFG::SpeculativeJIT::convertMachineInt): Deleted.
(JSC::DFG::SpeculativeJIT::speculateMachineInt): Deleted.
(JSC::DFG::SpeculativeJIT::speculateDoubleRepMachineInt): Deleted.
* dfg/DFGUseKind.cpp:
(WTF::printInternal):
* dfg/DFGUseKind.h:
(JSC::DFG::typeFilterFor):
(JSC::DFG::isNumerical):
(JSC::DFG::isDouble):
* dfg/DFGValidate.cpp:
* dfg/DFGVariableAccessData.cpp:
(JSC::DFG::VariableAccessData::makePredictionForDoubleFormat):
(JSC::DFG::VariableAccessData::couldRepresentInt52Impl):
(JSC::DFG::VariableAccessData::flushFormat):
* ftl/FTLCapabilities.cpp:
(JSC::FTL::canCompile):
* ftl/FTLLowerDFGToB3.cpp:
(JSC::FTL::DFG::LowerDFGToB3::compileInt52Constant):
(JSC::FTL::DFG::LowerDFGToB3::compileInt52Rep):
(JSC::FTL::DFG::LowerDFGToB3::compileArithAddOrSub):
(JSC::FTL::DFG::LowerDFGToB3::compileArithNegate):
(JSC::FTL::DFG::LowerDFGToB3::compileGetByVal):
(JSC::FTL::DFG::LowerDFGToB3::compilePutByVal):
(JSC::FTL::DFG::LowerDFGToB3::compileArrayPush):
(JSC::FTL::DFG::LowerDFGToB3::lowInt32):
(JSC::FTL::DFG::LowerDFGToB3::strictInt52ToInt32):
(JSC::FTL::DFG::LowerDFGToB3::isInt32):
(JSC::FTL::DFG::LowerDFGToB3::isNotInt32):
(JSC::FTL::DFG::LowerDFGToB3::jsValueToStrictInt52):
(JSC::FTL::DFG::LowerDFGToB3::doubleToStrictInt52):
(JSC::FTL::DFG::LowerDFGToB3::speculate):
(JSC::FTL::DFG::LowerDFGToB3::speculateCellOrOther):
(JSC::FTL::DFG::LowerDFGToB3::speculateAnyInt):
(JSC::FTL::DFG::LowerDFGToB3::speculateDoubleRepReal):
(JSC::FTL::DFG::LowerDFGToB3::speculateDoubleRepAnyInt):
(JSC::FTL::DFG::LowerDFGToB3::speculateMachineInt): Deleted.
(JSC::FTL::DFG::LowerDFGToB3::speculateDoubleRepMachineInt): Deleted.
* jit/JITOpcodes.cpp:
(JSC::JIT::emit_op_profile_type):
* jit/JITOpcodes32_64.cpp:
(JSC::JIT::emit_op_profile_type):
* runtime/JSCJSValue.h:
* runtime/JSCJSValueInlines.h:
(JSC::isInt52):
(JSC::JSValue::isAnyInt):
(JSC::JSValue::asAnyInt):
(JSC::JSValue::isMachineInt): Deleted.
(JSC::JSValue::asMachineInt): Deleted.
* runtime/RuntimeType.cpp:
(JSC::runtimeTypeForValue):
(JSC::runtimeTypeAsString):
* runtime/RuntimeType.h:
* runtime/TypeSet.cpp:
(JSC::TypeSet::dumpTypes):
(JSC::TypeSet::displayName):
(JSC::TypeSet::inspectorTypeSet):
(JSC::TypeSet::toJSONString):</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkSourceJavaScriptCoreChangeLog">trunk/Source/JavaScriptCore/ChangeLog</a></li>
<li><a href="#trunkSourceJavaScriptCorebindingsScriptValuecpp">trunk/Source/JavaScriptCore/bindings/ScriptValue.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorebytecodeSpeculatedTypecpp">trunk/Source/JavaScriptCore/bytecode/SpeculatedType.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorebytecodeSpeculatedTypeh">trunk/Source/JavaScriptCore/bytecode/SpeculatedType.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGAbstractInterpreterInlinesh">trunk/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGAbstractValuecpp">trunk/Source/JavaScriptCore/dfg/DFGAbstractValue.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGAbstractValueh">trunk/Source/JavaScriptCore/dfg/DFGAbstractValue.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGArgumentsUtilitiescpp">trunk/Source/JavaScriptCore/dfg/DFGArgumentsUtilities.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGByteCodeParsercpp">trunk/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGFixupPhasecpp">trunk/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGGraphh">trunk/Source/JavaScriptCore/dfg/DFGGraph.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGInPlaceAbstractStatecpp">trunk/Source/JavaScriptCore/dfg/DFGInPlaceAbstractState.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGJITCompilercpp">trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGNodecpp">trunk/Source/JavaScriptCore/dfg/DFGNode.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGNodeh">trunk/Source/JavaScriptCore/dfg/DFGNode.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGOSREntrycpp">trunk/Source/JavaScriptCore/dfg/DFGOSREntry.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGOSREntryh">trunk/Source/JavaScriptCore/dfg/DFGOSREntry.h</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGPredictionPropagationPhasecpp">trunk/Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGSSALoweringPhasecpp">trunk/Source/JavaScriptCore/dfg/DFGSSALoweringPhase.cpp</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="#trunkSourceJavaScriptCoredfgDFGValidatecpp">trunk/Source/JavaScriptCore/dfg/DFGValidate.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoredfgDFGVariableAccessDatacpp">trunk/Source/JavaScriptCore/dfg/DFGVariableAccessData.cpp</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="#trunkSourceJavaScriptCorejitJITOpcodescpp">trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCorejitJITOpcodes32_64cpp">trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreruntimeJSCJSValueh">trunk/Source/JavaScriptCore/runtime/JSCJSValue.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreruntimeJSCJSValueInlinesh">trunk/Source/JavaScriptCore/runtime/JSCJSValueInlines.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreruntimeRuntimeTypecpp">trunk/Source/JavaScriptCore/runtime/RuntimeType.cpp</a></li>
<li><a href="#trunkSourceJavaScriptCoreruntimeRuntimeTypeh">trunk/Source/JavaScriptCore/runtime/RuntimeType.h</a></li>
<li><a href="#trunkSourceJavaScriptCoreruntimeTypeSetcpp">trunk/Source/JavaScriptCore/runtime/TypeSet.cpp</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkSourceJavaScriptCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ChangeLog (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ChangeLog 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/ChangeLog 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -1,3 +1,191 @@
</span><ins>+2016-04-25 Mark Lam <mark.lam@apple.com>
+
+ Renaming SpecInt32, SpecInt52, MachineInt to SpecInt32Only, SpecInt52Only, AnyInt.
+ https://bugs.webkit.org/show_bug.cgi?id=156941
+
+ Reviewed by Filip Pizlo.
+
+ While looking at https://bugs.webkit.org/show_bug.cgi?id=153431, it was decided
+ that SpecInt32Only, SpecInt52Only, and AnyInt would be better names for
+ SpecInt32, SpecInt52, and MachineInt. Let's do a bulk rename.
+
+ This is only a renaming patch, and deletion of a piece of unused code. There are
+ no semantic changes.
+
+ * bindings/ScriptValue.cpp:
+ (Inspector::jsToInspectorValue):
+ * bytecode/SpeculatedType.cpp:
+ (JSC::dumpSpeculation):
+ (JSC::speculationToAbbreviatedString):
+ (JSC::speculationFromValue):
+ (JSC::leastUpperBoundOfStrictlyEquivalentSpeculations):
+ (JSC::typeOfDoubleNegation):
+ (JSC::typeOfDoubleRounding):
+ * bytecode/SpeculatedType.h:
+ (JSC::isInt32Speculation):
+ (JSC::isInt32OrBooleanSpeculation):
+ (JSC::isInt32SpeculationForArithmetic):
+ (JSC::isInt32OrBooleanSpeculationForArithmetic):
+ (JSC::isInt32OrBooleanSpeculationExpectingDefined):
+ (JSC::isInt52Speculation):
+ (JSC::isAnyIntSpeculation):
+ (JSC::isAnyIntAsDoubleSpeculation):
+ (JSC::isDoubleRealSpeculation):
+ (JSC::isMachineIntSpeculation): Deleted.
+ (JSC::isInt52AsDoubleSpeculation): Deleted.
+ (JSC::isIntegerSpeculation): Deleted.
+ * dfg/DFGAbstractInterpreterInlines.h:
+ (JSC::DFG::AbstractInterpreter<AbstractStateType>::executeEffects):
+ * dfg/DFGAbstractValue.cpp:
+ (JSC::DFG::AbstractValue::set):
+ (JSC::DFG::AbstractValue::fixTypeForRepresentation):
+ (JSC::DFG::AbstractValue::checkConsistency):
+ (JSC::DFG::AbstractValue::resultType):
+ * dfg/DFGAbstractValue.h:
+ (JSC::DFG::AbstractValue::validateType):
+ * dfg/DFGArgumentsUtilities.cpp:
+ (JSC::DFG::emitCodeToGetArgumentsArrayLength):
+ * dfg/DFGByteCodeParser.cpp:
+ (JSC::DFG::ByteCodeParser::handleInlining):
+ (JSC::DFG::ByteCodeParser::handleIntrinsicCall):
+ * dfg/DFGFixupPhase.cpp:
+ (JSC::DFG::FixupPhase::fixupNode):
+ (JSC::DFG::FixupPhase::fixupToThis):
+ (JSC::DFG::FixupPhase::observeUseKindOnNode):
+ (JSC::DFG::FixupPhase::fixIntConvertingEdge):
+ (JSC::DFG::FixupPhase::fixIntOrBooleanEdge):
+ (JSC::DFG::FixupPhase::fixDoubleOrBooleanEdge):
+ (JSC::DFG::FixupPhase::truncateConstantToInt32):
+ (JSC::DFG::FixupPhase::attemptToMakeIntegerAdd):
+ (JSC::DFG::FixupPhase::prependGetArrayLength):
+ (JSC::DFG::FixupPhase::fixupChecksInBlock):
+ * dfg/DFGGraph.h:
+ (JSC::DFG::Graph::addShouldSpeculateInt32):
+ (JSC::DFG::Graph::addShouldSpeculateAnyInt):
+ (JSC::DFG::Graph::binaryArithShouldSpeculateInt32):
+ (JSC::DFG::Graph::binaryArithShouldSpeculateAnyInt):
+ (JSC::DFG::Graph::unaryArithShouldSpeculateInt32):
+ (JSC::DFG::Graph::unaryArithShouldSpeculateAnyInt):
+ (JSC::DFG::Graph::addShouldSpeculateMachineInt): Deleted.
+ (JSC::DFG::Graph::binaryArithShouldSpeculateMachineInt): Deleted.
+ (JSC::DFG::Graph::unaryArithShouldSpeculateMachineInt): Deleted.
+ * dfg/DFGInPlaceAbstractState.cpp:
+ (JSC::DFG::InPlaceAbstractState::initialize):
+ * dfg/DFGJITCompiler.cpp:
+ (JSC::DFG::JITCompiler::noticeOSREntry):
+ * dfg/DFGNode.cpp:
+ (JSC::DFG::Node::convertToIdentityOn):
+ * dfg/DFGNode.h:
+ (JSC::DFG::Node::asNumber):
+ (JSC::DFG::Node::isAnyIntConstant):
+ (JSC::DFG::Node::asAnyInt):
+ (JSC::DFG::Node::isBooleanConstant):
+ (JSC::DFG::Node::shouldSpeculateInt32OrBooleanExpectingDefined):
+ (JSC::DFG::Node::shouldSpeculateAnyInt):
+ (JSC::DFG::Node::shouldSpeculateDouble):
+ (JSC::DFG::Node::shouldSpeculateNumber):
+ (JSC::DFG::Node::isMachineIntConstant): Deleted.
+ (JSC::DFG::Node::asMachineInt): Deleted.
+ (JSC::DFG::Node::shouldSpeculateMachineInt): Deleted.
+ * dfg/DFGOSREntry.cpp:
+ (JSC::DFG::OSREntryData::dumpInContext):
+ (JSC::DFG::prepareOSREntry):
+ * dfg/DFGOSREntry.h:
+ * dfg/DFGPredictionPropagationPhase.cpp:
+ * dfg/DFGSSALoweringPhase.cpp:
+ (JSC::DFG::SSALoweringPhase::handleNode):
+ (JSC::DFG::SSALoweringPhase::lowerBoundsCheck):
+ * dfg/DFGSafeToExecute.h:
+ (JSC::DFG::SafeToExecuteEdge::operator()):
+ * dfg/DFGSpeculativeJIT.cpp:
+ (JSC::DFG::SpeculativeJIT::silentFill):
+ (JSC::DFG::SpeculativeJIT::compileGetByValOnIntTypedArray):
+ (JSC::DFG::SpeculativeJIT::compileArithAdd):
+ (JSC::DFG::SpeculativeJIT::compileArithSub):
+ (JSC::DFG::SpeculativeJIT::compileArithNegate):
+ (JSC::DFG::SpeculativeJIT::speculateInt32):
+ (JSC::DFG::SpeculativeJIT::speculateNumber):
+ (JSC::DFG::SpeculativeJIT::speculateMisc):
+ (JSC::DFG::SpeculativeJIT::speculate):
+ * dfg/DFGSpeculativeJIT.h:
+ (JSC::DFG::SpeculativeJIT::spill):
+ (JSC::DFG::SpeculativeJIT::isKnownInteger):
+ (JSC::DFG::SpeculativeJIT::isKnownCell):
+ (JSC::DFG::SpeculativeJIT::isKnownNotInteger):
+ (JSC::DFG::SpeculativeJIT::isKnownNotNumber):
+ (JSC::DFG::SpeculativeJIT::isKnownNotCell):
+ (JSC::DFG::SpeculativeJIT::isKnownNotOther):
+ * dfg/DFGSpeculativeJIT32_64.cpp:
+ (JSC::DFG::SpeculativeJIT::fillSpeculateInt32Internal):
+ (JSC::DFG::SpeculativeJIT::compile):
+ * dfg/DFGSpeculativeJIT64.cpp:
+ (JSC::DFG::SpeculativeJIT::fillSpeculateInt32Internal):
+ (JSC::DFG::SpeculativeJIT::fillSpeculateInt52):
+ (JSC::DFG::SpeculativeJIT::fillSpeculateDouble):
+ (JSC::DFG::SpeculativeJIT::emitBranch):
+ (JSC::DFG::SpeculativeJIT::compile):
+ (JSC::DFG::SpeculativeJIT::blessBoolean):
+ (JSC::DFG::SpeculativeJIT::convertAnyInt):
+ (JSC::DFG::SpeculativeJIT::speculateAnyInt):
+ (JSC::DFG::SpeculativeJIT::speculateDoubleRepAnyInt):
+ (JSC::DFG::SpeculativeJIT::convertMachineInt): Deleted.
+ (JSC::DFG::SpeculativeJIT::speculateMachineInt): Deleted.
+ (JSC::DFG::SpeculativeJIT::speculateDoubleRepMachineInt): Deleted.
+ * dfg/DFGUseKind.cpp:
+ (WTF::printInternal):
+ * dfg/DFGUseKind.h:
+ (JSC::DFG::typeFilterFor):
+ (JSC::DFG::isNumerical):
+ (JSC::DFG::isDouble):
+ * dfg/DFGValidate.cpp:
+ * dfg/DFGVariableAccessData.cpp:
+ (JSC::DFG::VariableAccessData::makePredictionForDoubleFormat):
+ (JSC::DFG::VariableAccessData::couldRepresentInt52Impl):
+ (JSC::DFG::VariableAccessData::flushFormat):
+ * ftl/FTLCapabilities.cpp:
+ (JSC::FTL::canCompile):
+ * ftl/FTLLowerDFGToB3.cpp:
+ (JSC::FTL::DFG::LowerDFGToB3::compileInt52Constant):
+ (JSC::FTL::DFG::LowerDFGToB3::compileInt52Rep):
+ (JSC::FTL::DFG::LowerDFGToB3::compileArithAddOrSub):
+ (JSC::FTL::DFG::LowerDFGToB3::compileArithNegate):
+ (JSC::FTL::DFG::LowerDFGToB3::compileGetByVal):
+ (JSC::FTL::DFG::LowerDFGToB3::compilePutByVal):
+ (JSC::FTL::DFG::LowerDFGToB3::compileArrayPush):
+ (JSC::FTL::DFG::LowerDFGToB3::lowInt32):
+ (JSC::FTL::DFG::LowerDFGToB3::strictInt52ToInt32):
+ (JSC::FTL::DFG::LowerDFGToB3::isInt32):
+ (JSC::FTL::DFG::LowerDFGToB3::isNotInt32):
+ (JSC::FTL::DFG::LowerDFGToB3::jsValueToStrictInt52):
+ (JSC::FTL::DFG::LowerDFGToB3::doubleToStrictInt52):
+ (JSC::FTL::DFG::LowerDFGToB3::speculate):
+ (JSC::FTL::DFG::LowerDFGToB3::speculateCellOrOther):
+ (JSC::FTL::DFG::LowerDFGToB3::speculateAnyInt):
+ (JSC::FTL::DFG::LowerDFGToB3::speculateDoubleRepReal):
+ (JSC::FTL::DFG::LowerDFGToB3::speculateDoubleRepAnyInt):
+ (JSC::FTL::DFG::LowerDFGToB3::speculateMachineInt): Deleted.
+ (JSC::FTL::DFG::LowerDFGToB3::speculateDoubleRepMachineInt): Deleted.
+ * jit/JITOpcodes.cpp:
+ (JSC::JIT::emit_op_profile_type):
+ * jit/JITOpcodes32_64.cpp:
+ (JSC::JIT::emit_op_profile_type):
+ * runtime/JSCJSValue.h:
+ * runtime/JSCJSValueInlines.h:
+ (JSC::isInt52):
+ (JSC::JSValue::isAnyInt):
+ (JSC::JSValue::asAnyInt):
+ (JSC::JSValue::isMachineInt): Deleted.
+ (JSC::JSValue::asMachineInt): Deleted.
+ * runtime/RuntimeType.cpp:
+ (JSC::runtimeTypeForValue):
+ (JSC::runtimeTypeAsString):
+ * runtime/RuntimeType.h:
+ * runtime/TypeSet.cpp:
+ (JSC::TypeSet::dumpTypes):
+ (JSC::TypeSet::displayName):
+ (JSC::TypeSet::inspectorTypeSet):
+ (JSC::TypeSet::toJSONString):
+
</ins><span class="cx"> 2016-04-24 Yusuke Suzuki <utatane.tea@gmail.com>
</span><span class="cx">
</span><span class="cx"> [JSC] Optimize JSON.parse string fast path
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorebindingsScriptValuecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/bindings/ScriptValue.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/bindings/ScriptValue.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/bindings/ScriptValue.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -58,8 +58,8 @@
</span><span class="cx"> return InspectorValue::create(value.asBoolean());
</span><span class="cx"> if (value.isNumber() && value.isDouble())
</span><span class="cx"> return InspectorValue::create(value.asNumber());
</span><del>- if (value.isNumber() && value.isMachineInt())
- return InspectorValue::create(static_cast<int>(value.asMachineInt()));
</del><ins>+ if (value.isNumber() && value.isAnyInt())
+ return InspectorValue::create(static_cast<int>(value.asAnyInt()));
</ins><span class="cx"> if (value.isString())
</span><span class="cx"> return InspectorValue::create(value.getString(&scriptState));
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorebytecodeSpeculatedTypecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/bytecode/SpeculatedType.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/bytecode/SpeculatedType.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/bytecode/SpeculatedType.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -168,7 +168,7 @@
</span><span class="cx"> isTop = false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (value == SpecInt32)
</del><ins>+ if (value == SpecInt32Only)
</ins><span class="cx"> myOut.print("Int32");
</span><span class="cx"> else {
</span><span class="cx"> if (value & SpecBoolInt32)
</span><span class="lines">@@ -182,14 +182,14 @@
</span><span class="cx"> isTop = false;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (value & SpecInt52)
</del><ins>+ if (value & SpecInt52Only)
</ins><span class="cx"> myOut.print("Int52");
</span><span class="cx">
</span><span class="cx"> if ((value & SpecBytecodeDouble) == SpecBytecodeDouble)
</span><span class="cx"> myOut.print("Bytecodedouble");
</span><span class="cx"> else {
</span><del>- if (value & SpecInt52AsDouble)
- myOut.print("Int52asdouble");
</del><ins>+ if (value & SpecAnyIntAsDouble)
+ myOut.print("AnyIntAsDouble");
</ins><span class="cx"> else
</span><span class="cx"> isTop = false;
</span><span class="cx">
</span><span class="lines">@@ -274,12 +274,12 @@
</span><span class="cx"> return "<BoolInt32>";
</span><span class="cx"> if (isInt32Speculation(prediction))
</span><span class="cx"> return "<Int32>";
</span><del>- if (isInt52AsDoubleSpeculation(prediction))
- return "<Int52AsDouble>";
</del><ins>+ if (isAnyIntAsDoubleSpeculation(prediction))
+ return "<AnyIntAsDouble>";
</ins><span class="cx"> if (isInt52Speculation(prediction))
</span><span class="cx"> return "<Int52>";
</span><del>- if (isMachineIntSpeculation(prediction))
- return "<MachineInt>";
</del><ins>+ if (isAnyIntSpeculation(prediction))
+ return "<AnyInt>";
</ins><span class="cx"> if (isDoubleSpeculation(prediction))
</span><span class="cx"> return "<Double>";
</span><span class="cx"> if (isFullNumberSpeculation(prediction))
</span><span class="lines">@@ -393,8 +393,8 @@
</span><span class="cx"> double number = value.asNumber();
</span><span class="cx"> if (number != number)
</span><span class="cx"> return SpecDoublePureNaN;
</span><del>- if (value.isMachineInt())
- return SpecInt52AsDouble;
</del><ins>+ if (value.isAnyInt())
+ return SpecAnyIntAsDouble;
</ins><span class="cx"> return SpecNonIntAsDouble;
</span><span class="cx"> }
</span><span class="cx"> if (value.isCell())
</span><span class="lines">@@ -439,8 +439,8 @@
</span><span class="cx">
</span><span class="cx"> SpeculatedType leastUpperBoundOfStrictlyEquivalentSpeculations(SpeculatedType type)
</span><span class="cx"> {
</span><del>- if (type & SpecInteger)
- type |= SpecInteger;
</del><ins>+ if (type & (SpecAnyInt | SpecAnyIntAsDouble))
+ type |= (SpecAnyInt | SpecAnyIntAsDouble);
</ins><span class="cx"> if (type & SpecString)
</span><span class="cx"> type |= SpecString;
</span><span class="cx"> return type;
</span><span class="lines">@@ -526,7 +526,7 @@
</span><span class="cx"> // 0xefff000000000000 (pure) - 0xffff000000000000 (impure)
</span><span class="cx"> if (value & SpecDoubleNaN)
</span><span class="cx"> value |= SpecDoubleNaN;
</span><del>- // We could get negative zero, which mixes SpecInt52AsDouble and SpecNotIntAsDouble.
</del><ins>+ // We could get negative zero, which mixes SpecAnyIntAsDouble and SpecNotIntAsDouble.
</ins><span class="cx"> // We could also overflow a large negative int into something that is no longer
</span><span class="cx"> // representable as an int.
</span><span class="cx"> if (value & SpecDoubleReal)
</span><span class="lines">@@ -547,7 +547,7 @@
</span><span class="cx"> value |= SpecDoubleNaN;
</span><span class="cx"> // We might lose bits, which leads to a value becoming integer-representable.
</span><span class="cx"> if (value & SpecNonIntAsDouble)
</span><del>- value |= SpecInt52AsDouble;
</del><ins>+ value |= SpecAnyIntAsDouble;
</ins><span class="cx"> return value;
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorebytecodeSpeculatedTypeh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/bytecode/SpeculatedType.h (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/bytecode/SpeculatedType.h 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/bytecode/SpeculatedType.h 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -66,29 +66,28 @@
</span><span class="cx"> static const SpeculatedType SpecCell = SpecObject | SpecString | SpecSymbol | SpecCellOther; // It's definitely a JSCell.
</span><span class="cx"> static const SpeculatedType SpecBoolInt32 = 1u << 21; // It's definitely an Int32 with value 0 or 1.
</span><span class="cx"> static const SpeculatedType SpecNonBoolInt32 = 1u << 22; // It's definitely an Int32 with value other than 0 or 1.
</span><del>-static const SpeculatedType SpecInt32 = SpecBoolInt32 | SpecNonBoolInt32; // It's definitely an Int32.
-static const SpeculatedType SpecInt52 = 1u << 23; // It's definitely an Int52 and we intend it to unbox it. It's also definitely not an Int32.
-static const SpeculatedType SpecMachineInt = SpecInt32 | SpecInt52; // It's something that we can do machine int arithmetic on.
-static const SpeculatedType SpecInt52AsDouble = 1u << 24; // It's definitely an Int52 and it's inside a double.
-static const SpeculatedType SpecInteger = SpecMachineInt | SpecInt52AsDouble; // It's definitely some kind of integer.
</del><ins>+static const SpeculatedType SpecInt32Only = SpecBoolInt32 | SpecNonBoolInt32; // It's definitely an Int32.
+static const SpeculatedType SpecInt52Only = 1u << 23; // It's definitely an Int52 and we intend it to unbox it. It's also definitely not an Int32.
+static const SpeculatedType SpecAnyInt = SpecInt32Only | SpecInt52Only; // It's something that we can do machine int arithmetic on.
+static const SpeculatedType SpecAnyIntAsDouble = 1u << 24; // It's definitely an Int52 and it's inside a double.
</ins><span class="cx"> static const SpeculatedType SpecNonIntAsDouble = 1u << 25; // It's definitely not an Int52 but it's a real number and it's a double.
</span><del>-static const SpeculatedType SpecDoubleReal = SpecNonIntAsDouble | SpecInt52AsDouble; // It's definitely a non-NaN double.
</del><ins>+static const SpeculatedType SpecDoubleReal = SpecNonIntAsDouble | SpecAnyIntAsDouble; // It's definitely a non-NaN double.
</ins><span class="cx"> static const SpeculatedType SpecDoublePureNaN = 1u << 26; // It's definitely a NaN that is sae to tag (i.e. pure).
</span><span class="cx"> static const SpeculatedType SpecDoubleImpureNaN = 1u << 27; // It's definitely a NaN that is unsafe to tag (i.e. impure).
</span><span class="cx"> static const SpeculatedType SpecDoubleNaN = SpecDoublePureNaN | SpecDoubleImpureNaN; // It's definitely some kind of NaN.
</span><span class="cx"> static const SpeculatedType SpecBytecodeDouble = SpecDoubleReal | SpecDoublePureNaN; // It's either a non-NaN or a NaN double, but it's definitely not impure NaN.
</span><span class="cx"> static const SpeculatedType SpecFullDouble = SpecDoubleReal | SpecDoubleNaN; // It's either a non-NaN or a NaN double.
</span><del>-static const SpeculatedType SpecBytecodeRealNumber = SpecInt32 | SpecDoubleReal; // It's either an Int32 or a DoubleReal.
-static const SpeculatedType SpecFullRealNumber = SpecMachineInt | SpecDoubleReal; // It's either an Int32 or a DoubleReal, or a Int52.
-static const SpeculatedType SpecBytecodeNumber = SpecInt32 | SpecBytecodeDouble; // It's either an Int32 or a Double, and the Double cannot be an impure NaN.
-static const SpeculatedType SpecFullNumber = SpecMachineInt | SpecFullDouble; // It's either an Int32, Int52, or a Double, and the Double can be impure NaN.
</del><ins>+static const SpeculatedType SpecBytecodeRealNumber = SpecInt32Only | SpecDoubleReal; // It's either an Int32 or a DoubleReal.
+static const SpeculatedType SpecFullRealNumber = SpecAnyInt | SpecDoubleReal; // It's either an Int32 or a DoubleReal, or a Int52.
+static const SpeculatedType SpecBytecodeNumber = SpecInt32Only | SpecBytecodeDouble; // It's either an Int32 or a Double, and the Double cannot be an impure NaN.
+static const SpeculatedType SpecFullNumber = SpecAnyInt | SpecFullDouble; // It's either an Int32, Int52, or a Double, and the Double can be impure NaN.
</ins><span class="cx"> static const SpeculatedType SpecBoolean = 1u << 28; // It's definitely a Boolean.
</span><span class="cx"> static const SpeculatedType SpecOther = 1u << 29; // It's definitely either Null or Undefined.
</span><span class="cx"> static const SpeculatedType SpecMisc = SpecBoolean | SpecOther; // It's definitely either a boolean, Null, or Undefined.
</span><del>-static const SpeculatedType SpecHeapTop = SpecCell | SpecBytecodeNumber | SpecMisc; // It can be any of the above, except for SpecInt52 and SpecDoubleImpureNaN.
</del><ins>+static const SpeculatedType SpecHeapTop = SpecCell | SpecBytecodeNumber | SpecMisc; // It can be any of the above, except for SpecInt52Only and SpecDoubleImpureNaN.
</ins><span class="cx"> static const SpeculatedType SpecPrimitive = SpecString | SpecSymbol | SpecBytecodeNumber | SpecMisc; // It's any non-Object JSValue.
</span><span class="cx"> static const SpeculatedType SpecEmpty = 1u << 30; // It's definitely an empty value marker.
</span><del>-static const SpeculatedType SpecBytecodeTop = SpecHeapTop | SpecEmpty; // It can be any of the above, except for SpecInt52 and SpecDoubleImpureNaN. Corresponds to what could be found in a bytecode local.
</del><ins>+static const SpeculatedType SpecBytecodeTop = SpecHeapTop | SpecEmpty; // It can be any of the above, except for SpecInt52Only and SpecDoubleImpureNaN. Corresponds to what could be found in a bytecode local.
</ins><span class="cx"> static const SpeculatedType SpecFullTop = SpecBytecodeTop | SpecFullNumber; // It can be anything that bytecode could see plus exotic encodings of numbers.
</span><span class="cx">
</span><span class="cx"> typedef bool (*SpeculatedTypeChecker)(SpeculatedType);
</span><span class="lines">@@ -288,22 +287,22 @@
</span><span class="cx">
</span><span class="cx"> inline bool isInt32Speculation(SpeculatedType value)
</span><span class="cx"> {
</span><del>- return value && !(value & ~SpecInt32);
</del><ins>+ return value && !(value & ~SpecInt32Only);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline bool isInt32OrBooleanSpeculation(SpeculatedType value)
</span><span class="cx"> {
</span><del>- return value && !(value & ~(SpecBoolean | SpecInt32));
</del><ins>+ return value && !(value & ~(SpecBoolean | SpecInt32Only));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline bool isInt32SpeculationForArithmetic(SpeculatedType value)
</span><span class="cx"> {
</span><del>- return !(value & (SpecFullDouble | SpecInt52));
</del><ins>+ return !(value & (SpecFullDouble | SpecInt52Only));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline bool isInt32OrBooleanSpeculationForArithmetic(SpeculatedType value)
</span><span class="cx"> {
</span><del>- return !(value & (SpecFullDouble | SpecInt52));
</del><ins>+ return !(value & (SpecFullDouble | SpecInt52Only));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> inline bool isInt32OrBooleanSpeculationExpectingDefined(SpeculatedType value)
</span><span class="lines">@@ -313,24 +312,19 @@
</span><span class="cx">
</span><span class="cx"> inline bool isInt52Speculation(SpeculatedType value)
</span><span class="cx"> {
</span><del>- return value == SpecInt52;
</del><ins>+ return value == SpecInt52Only;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool isMachineIntSpeculation(SpeculatedType value)
</del><ins>+inline bool isAnyIntSpeculation(SpeculatedType value)
</ins><span class="cx"> {
</span><del>- return !!value && (value & SpecMachineInt) == value;
</del><ins>+ return !!value && (value & SpecAnyInt) == value;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool isInt52AsDoubleSpeculation(SpeculatedType value)
</del><ins>+inline bool isAnyIntAsDoubleSpeculation(SpeculatedType value)
</ins><span class="cx"> {
</span><del>- return value == SpecInt52AsDouble;
</del><ins>+ return value == SpecAnyIntAsDouble;
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool isIntegerSpeculation(SpeculatedType value)
-{
- return !!value && (value & SpecInteger) == value;
-}
-
</del><span class="cx"> inline bool isDoubleRealSpeculation(SpeculatedType value)
</span><span class="cx"> {
</span><span class="cx"> return !!value && (value & SpecDoubleReal) == value;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGAbstractInterpreterInlinesh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -237,7 +237,7 @@
</span><span class="cx"> // https://bugs.webkit.org/show_bug.cgi?id=143071
</span><span class="cx"> clobberWorld(node->origin.semantic, clobberLimit);
</span><span class="cx"> LoadVarargsData* data = node->loadVarargsData();
</span><del>- m_state.variables().operand(data->count).setType(SpecInt32);
</del><ins>+ m_state.variables().operand(data->count).setType(SpecInt32Only);
</ins><span class="cx"> for (unsigned i = data->limit - 1; i--;)
</span><span class="cx"> m_state.variables().operand(data->start.offset() + i).makeHeapTop();
</span><span class="cx"> break;
</span><span class="lines">@@ -251,7 +251,7 @@
</span><span class="cx"> case BitURShift: {
</span><span class="cx"> if (node->child1().useKind() == UntypedUse || node->child2().useKind() == UntypedUse) {
</span><span class="cx"> clobberWorld(node->origin.semantic, clobberLimit);
</span><del>- forNode(node).setType(m_graph, SpecInt32);
</del><ins>+ forNode(node).setType(m_graph, SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -293,7 +293,7 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -301,11 +301,11 @@
</span><span class="cx"> JSValue child = forNode(node->child1()).value();
</span><span class="cx"> if (doesOverflow(node->arithMode())) {
</span><span class="cx"> if (enableInt52()) {
</span><del>- if (child && child.isMachineInt()) {
- setConstant(node, jsNumber(child.asMachineInt()));
</del><ins>+ if (child && child.isAnyInt()) {
+ setConstant(node, jsNumber(child.asAnyInt()));
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecMachineInt);
</del><ins>+ forNode(node).setType(SpecAnyInt);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> if (child && child.isInt32()) {
</span><span class="lines">@@ -313,7 +313,7 @@
</span><span class="cx"> setConstant(node, jsNumber(value));
</span><span class="cx"> break;
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecInt52AsDouble);
</del><ins>+ forNode(node).setType(SpecAnyIntAsDouble);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> if (child && child.isInt32()) {
</span><span class="lines">@@ -323,7 +323,7 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -357,7 +357,7 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -386,7 +386,7 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -441,12 +441,12 @@
</span><span class="cx">
</span><span class="cx"> case Int52Rep: {
</span><span class="cx"> JSValue child = forNode(node->child1()).value();
</span><del>- if (child && child.isMachineInt()) {
</del><ins>+ if (child && child.isAnyInt()) {
</ins><span class="cx"> setConstant(node, child);
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -490,17 +490,17 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case Int52RepUse:
</span><del>- if (left && right && left.isMachineInt() && right.isMachineInt()) {
- JSValue result = jsNumber(left.asMachineInt() + right.asMachineInt());
- if (result.isMachineInt()) {
</del><ins>+ if (left && right && left.isAnyInt() && right.isAnyInt()) {
+ JSValue result = jsNumber(left.asAnyInt() + right.asAnyInt());
+ if (result.isAnyInt()) {
</ins><span class="cx"> setConstant(node, result);
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecMachineInt);
</del><ins>+ forNode(node).setType(SpecAnyInt);
</ins><span class="cx"> break;
</span><span class="cx"> case DoubleRepUse:
</span><span class="cx"> if (left && right && left.isNumber() && right.isNumber()) {
</span><span class="lines">@@ -525,7 +525,7 @@
</span><span class="cx"> setConstant(node, jsNumber(clz32(value)));
</span><span class="cx"> break;
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -550,17 +550,17 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case Int52RepUse:
</span><del>- if (left && right && left.isMachineInt() && right.isMachineInt()) {
- JSValue result = jsNumber(left.asMachineInt() - right.asMachineInt());
- if (result.isMachineInt() || !shouldCheckOverflow(node->arithMode())) {
</del><ins>+ if (left && right && left.isAnyInt() && right.isAnyInt()) {
+ JSValue result = jsNumber(left.asAnyInt() - right.asAnyInt());
+ if (result.isAnyInt() || !shouldCheckOverflow(node->arithMode())) {
</ins><span class="cx"> setConstant(node, result);
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecMachineInt);
</del><ins>+ forNode(node).setType(SpecAnyInt);
</ins><span class="cx"> break;
</span><span class="cx"> case DoubleRepUse:
</span><span class="cx"> if (left && right && left.isNumber() && right.isNumber()) {
</span><span class="lines">@@ -602,22 +602,22 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case Int52RepUse:
</span><del>- if (child && child.isMachineInt()) {
</del><ins>+ if (child && child.isAnyInt()) {
</ins><span class="cx"> double doubleResult;
</span><span class="cx"> if (shouldCheckNegativeZero(node->arithMode()))
</span><span class="cx"> doubleResult = -child.asNumber();
</span><span class="cx"> else
</span><span class="cx"> doubleResult = 0 - child.asNumber();
</span><span class="cx"> JSValue valueResult = jsNumber(doubleResult);
</span><del>- if (valueResult.isMachineInt()) {
</del><ins>+ if (valueResult.isAnyInt()) {
</ins><span class="cx"> setConstant(node, valueResult);
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecMachineInt);
</del><ins>+ forNode(node).setType(SpecAnyInt);
</ins><span class="cx"> break;
</span><span class="cx"> case DoubleRepUse:
</span><span class="cx"> if (child && child.isNumber()) {
</span><span class="lines">@@ -654,20 +654,20 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case Int52RepUse:
</span><del>- if (left && right && left.isMachineInt() && right.isMachineInt()) {
</del><ins>+ if (left && right && left.isAnyInt() && right.isAnyInt()) {
</ins><span class="cx"> double doubleResult = left.asNumber() * right.asNumber();
</span><span class="cx"> if (!shouldCheckNegativeZero(node->arithMode()))
</span><span class="cx"> doubleResult += 0;
</span><span class="cx"> JSValue valueResult = jsNumber(doubleResult);
</span><del>- if (valueResult.isMachineInt()) {
</del><ins>+ if (valueResult.isAnyInt()) {
</ins><span class="cx"> setConstant(node, valueResult);
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecMachineInt);
</del><ins>+ forNode(node).setType(SpecAnyInt);
</ins><span class="cx"> break;
</span><span class="cx"> case DoubleRepUse:
</span><span class="cx"> if (left && right && left.isNumber() && right.isNumber()) {
</span><span class="lines">@@ -706,7 +706,7 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case DoubleRepUse:
</span><span class="cx"> if (left && right && left.isNumber() && right.isNumber()) {
</span><span class="lines">@@ -745,7 +745,7 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case DoubleRepUse:
</span><span class="cx"> if (left && right && left.isNumber() && right.isNumber()) {
</span><span class="lines">@@ -772,7 +772,7 @@
</span><span class="cx"> setConstant(node, jsNumber(std::min(left.asInt32(), right.asInt32())));
</span><span class="cx"> break;
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case DoubleRepUse:
</span><span class="cx"> if (left && right && left.isNumber() && right.isNumber()) {
</span><span class="lines">@@ -801,7 +801,7 @@
</span><span class="cx"> setConstant(node, jsNumber(std::max(left.asInt32(), right.asInt32())));
</span><span class="cx"> break;
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case DoubleRepUse:
</span><span class="cx"> if (left && right && left.isNumber() && right.isNumber()) {
</span><span class="lines">@@ -832,7 +832,7 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case DoubleRepUse:
</span><span class="cx"> if (child && child.isNumber()) {
</span><span class="lines">@@ -908,7 +908,7 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> if (producesInteger(node->arithRoundingMode()))
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> else
</span><span class="cx"> forNode(node).setType(typeOfDoubleRounding(forNode(node->child1()).m_type));
</span><span class="cx"> break;
</span><span class="lines">@@ -1462,7 +1462,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> case StringCharCodeAt:
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case StringFromCharCode:
</span><span class="lines">@@ -1522,7 +1522,7 @@
</span><span class="cx"> clobberWorld(node->origin.semantic, clobberLimit);
</span><span class="cx"> forNode(node).makeHeapTop();
</span><span class="cx"> } else
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case Array::Double:
</span><span class="cx"> if (node->arrayMode().isOutOfBounds()) {
</span><span class="lines">@@ -1541,30 +1541,30 @@
</span><span class="cx"> forNode(node).makeHeapTop();
</span><span class="cx"> break;
</span><span class="cx"> case Array::Int8Array:
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case Array::Int16Array:
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case Array::Int32Array:
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case Array::Uint8Array:
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case Array::Uint8ClampedArray:
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case Array::Uint16Array:
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case Array::Uint32Array:
</span><span class="cx"> if (node->shouldSpeculateInt32())
</span><del>- forNode(node).setType(SpecInt32);
- else if (enableInt52() && node->shouldSpeculateMachineInt())
- forNode(node).setType(SpecMachineInt);
</del><ins>+ forNode(node).setType(SpecInt32Only);
+ else if (enableInt52() && node->shouldSpeculateAnyInt())
+ forNode(node).setType(SpecAnyInt);
</ins><span class="cx"> else
</span><del>- forNode(node).setType(SpecInt52AsDouble);
</del><ins>+ forNode(node).setType(SpecAnyIntAsDouble);
</ins><span class="cx"> break;
</span><span class="cx"> case Array::Float32Array:
</span><span class="cx"> forNode(node).setType(SpecFullDouble);
</span><span class="lines">@@ -1967,11 +1967,11 @@
</span><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case GetArgumentCount:
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case GetRestLength:
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case GetGetter: {
</span><span class="lines">@@ -2124,7 +2124,7 @@
</span><span class="cx"> setConstant(node, jsNumber(view->length()));
</span><span class="cx"> break;
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2350,7 +2350,7 @@
</span><span class="cx"> setConstant(node, jsNumber(view->byteOffset()));
</span><span class="cx"> break;
</span><span class="cx"> }
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2632,7 +2632,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> case GetEnumerableLength: {
</span><del>- forNode(node).setType(SpecInt32);
</del><ins>+ forNode(node).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case HasGenericProperty: {
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGAbstractValuecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGAbstractValue.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGAbstractValue.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGAbstractValue.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -130,7 +130,7 @@
</span><span class="cx"> setType(SpecOther);
</span><span class="cx"> return;
</span><span class="cx"> case InferredType::Int32:
</span><del>- setType(SpecInt32);
</del><ins>+ setType(SpecInt32Only);
</ins><span class="cx"> return;
</span><span class="cx"> case InferredType::Number:
</span><span class="cx"> setType(SpecBytecodeNumber);
</span><span class="lines">@@ -178,23 +178,23 @@
</span><span class="cx"> if (m_value.isInt32())
</span><span class="cx"> m_value = jsDoubleNumber(m_value.asNumber());
</span><span class="cx"> }
</span><del>- if (m_type & SpecMachineInt) {
- m_type &= ~SpecMachineInt;
- m_type |= SpecInt52AsDouble;
</del><ins>+ if (m_type & SpecAnyInt) {
+ m_type &= ~SpecAnyInt;
+ m_type |= SpecAnyIntAsDouble;
</ins><span class="cx"> }
</span><span class="cx"> if (m_type & ~SpecFullDouble)
</span><span class="cx"> DFG_CRASH(graph, node, toCString("Abstract value ", *this, " for double node has type outside SpecFullDouble.\n").data());
</span><span class="cx"> } else if (representation == NodeResultInt52) {
</span><del>- if (m_type & SpecInt52AsDouble) {
- m_type &= ~SpecInt52AsDouble;
- m_type |= SpecInt52;
</del><ins>+ if (m_type & SpecAnyIntAsDouble) {
+ m_type &= ~SpecAnyIntAsDouble;
+ m_type |= SpecInt52Only;
</ins><span class="cx"> }
</span><del>- if (m_type & ~SpecMachineInt)
- DFG_CRASH(graph, node, toCString("Abstract value ", *this, " for int52 node has type outside SpecMachineInt.\n").data());
</del><ins>+ if (m_type & ~SpecAnyInt)
+ DFG_CRASH(graph, node, toCString("Abstract value ", *this, " for int52 node has type outside SpecAnyInt.\n").data());
</ins><span class="cx"> } else {
</span><del>- if (m_type & SpecInt52) {
- m_type &= ~SpecInt52;
- m_type |= SpecInt52AsDouble;
</del><ins>+ if (m_type & SpecInt52Only) {
+ m_type &= ~SpecInt52Only;
+ m_type |= SpecAnyIntAsDouble;
</ins><span class="cx"> }
</span><span class="cx"> if (m_type & ~SpecBytecodeTop)
</span><span class="cx"> DFG_CRASH(graph, node, toCString("Abstract value ", *this, " for value node has type outside SpecBytecodeTop.\n").data());
</span><span class="lines">@@ -480,8 +480,8 @@
</span><span class="cx"> SpeculatedType type = m_type;
</span><span class="cx"> // This relaxes the assertion below a bit, since we don't know the representation of the
</span><span class="cx"> // node.
</span><del>- if (type & SpecInt52)
- type |= SpecInt52AsDouble;
</del><ins>+ if (type & SpecInt52Only)
+ type |= SpecAnyIntAsDouble;
</ins><span class="cx"> ASSERT(mergeSpeculations(type, speculationFromValue(m_value)) == type);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -502,7 +502,7 @@
</span><span class="cx"> ASSERT(isType(SpecBytecodeTop));
</span><span class="cx"> if (isType(SpecBoolean))
</span><span class="cx"> return ResultType::booleanType();
</span><del>- if (isType(SpecInt32))
</del><ins>+ if (isType(SpecInt32Only))
</ins><span class="cx"> return ResultType::numberTypeIsInt32();
</span><span class="cx"> if (isType(SpecBytecodeNumber))
</span><span class="cx"> return ResultType::numberType();
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGAbstractValueh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGAbstractValue.h (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGAbstractValue.h 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGAbstractValue.h 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -376,7 +376,7 @@
</span><span class="cx"> // abstract value that consists of the union of the set of all non-cell values
</span><span class="cx"> // and the set of cell values that have the given structure. This abstract
</span><span class="cx"> // value is then the intersection of the m_structure and the set of values
</span><del>- // whose type is m_type. So, for example if m_type is SpecFinal|SpecInt32 and
</del><ins>+ // whose type is m_type. So, for example if m_type is SpecFinal|SpecInt32Only and
</ins><span class="cx"> // m_structure is [0x12345] then this abstract value corresponds to the set of
</span><span class="cx"> // all integers unified with the set of all objects with structure 0x12345.
</span><span class="cx"> SpeculatedType m_type;
</span><span class="lines">@@ -419,12 +419,12 @@
</span><span class="cx"> if (isHeapTop())
</span><span class="cx"> return true;
</span><span class="cx">
</span><del>- // Constant folding always represents Int52's in a double (i.e. Int52AsDouble).
- // So speculationFromValue(value) for an Int52 value will return Int52AsDouble,
</del><ins>+ // Constant folding always represents Int52's in a double (i.e. AnyIntAsDouble).
+ // So speculationFromValue(value) for an Int52 value will return AnyIntAsDouble,
</ins><span class="cx"> // and that's fine - the type validates just fine.
</span><span class="cx"> SpeculatedType type = m_type;
</span><del>- if (type & SpecInt52)
- type |= SpecInt52AsDouble;
</del><ins>+ if (type & SpecInt52Only)
+ type |= SpecAnyIntAsDouble;
</ins><span class="cx">
</span><span class="cx"> if (mergeSpeculations(type, speculationFromValue(value)) != type)
</span><span class="cx"> return false;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGArgumentsUtilitiescpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGArgumentsUtilities.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGArgumentsUtilities.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGArgumentsUtilities.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -76,17 +76,17 @@
</span><span class="cx">
</span><span class="cx"> Node* argumentCount;
</span><span class="cx"> if (!inlineCallFrame)
</span><del>- argumentCount = insertionSet.insertNode(nodeIndex, SpecInt32, GetArgumentCount, origin);
</del><ins>+ argumentCount = insertionSet.insertNode(nodeIndex, SpecInt32Only, GetArgumentCount, origin);
</ins><span class="cx"> else {
</span><span class="cx"> VirtualRegister argumentCountRegister(inlineCallFrame->stackOffset + JSStack::ArgumentCount);
</span><span class="cx">
</span><span class="cx"> argumentCount = insertionSet.insertNode(
</span><del>- nodeIndex, SpecInt32, GetStack, origin,
</del><ins>+ nodeIndex, SpecInt32Only, GetStack, origin,
</ins><span class="cx"> OpInfo(graph.m_stackAccessData.add(argumentCountRegister, FlushedInt32)));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> return insertionSet.insertNode(
</span><del>- nodeIndex, SpecInt32, ArithSub, origin, OpInfo(Arith::Unchecked),
</del><ins>+ nodeIndex, SpecInt32Only, ArithSub, origin, OpInfo(Arith::Unchecked),
</ins><span class="cx"> Edge(argumentCount, Int32Use),
</span><span class="cx"> insertionSet.insertConstantForUse(
</span><span class="cx"> nodeIndex, origin, jsNumber(1), Int32Use));
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGByteCodeParsercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -1744,7 +1744,7 @@
</span><span class="cx"> // This is pretty lame, but it will force the count to be flushed as an int. This doesn't
</span><span class="cx"> // matter very much, since our use of a SetArgument and Flushes for this local slot is
</span><span class="cx"> // mostly just a formality.
</span><del>- countVariable->predict(SpecInt32);
</del><ins>+ countVariable->predict(SpecInt32Only);
</ins><span class="cx"> countVariable->mergeIsProfitableToUnbox(true);
</span><span class="cx"> Node* setArgumentCount = addToGraph(SetArgument, OpInfo(countVariable));
</span><span class="cx"> m_currentBlock->variablesAtTail.setOperand(countVariable->local(), setArgumentCount);
</span><span class="lines">@@ -2346,7 +2346,7 @@
</span><span class="cx"> for (int i = 1; i < argumentCountIncludingThis; ++i) {
</span><span class="cx"> Node* node = get(virtualRegisterForArgument(i, registerOffset));
</span><span class="cx"> if (node->hasHeapPrediction())
</span><del>- node->setHeapPrediction(SpecInt32);
</del><ins>+ node->setHeapPrediction(SpecInt32Only);
</ins><span class="cx"> }
</span><span class="cx"> set(VirtualRegister(resultOperand), addToGraph(JSConstant, OpInfo(m_constantUndefined)));
</span><span class="cx"> return true;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGFixupPhasecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -219,7 +219,7 @@
</span><span class="cx"> node->setArithMode(Arith::CheckOverflowAndNegativeZero);
</span><span class="cx"> break;
</span><span class="cx"> }
</span><del>- if (m_graph.unaryArithShouldSpeculateMachineInt(node, FixupPass)) {
</del><ins>+ if (m_graph.unaryArithShouldSpeculateAnyInt(node, FixupPass)) {
</ins><span class="cx"> fixEdge<Int52RepUse>(node->child1());
</span><span class="cx"> if (bytecodeCanIgnoreNegativeZero(node->arithNodeFlags()))
</span><span class="cx"> node->setArithMode(Arith::CheckOverflow);
</span><span class="lines">@@ -255,7 +255,7 @@
</span><span class="cx"> node->setArithMode(Arith::CheckOverflowAndNegativeZero);
</span><span class="cx"> break;
</span><span class="cx"> }
</span><del>- if (m_graph.binaryArithShouldSpeculateMachineInt(node, FixupPass)) {
</del><ins>+ if (m_graph.binaryArithShouldSpeculateAnyInt(node, FixupPass)) {
</ins><span class="cx"> fixEdge<Int52RepUse>(leftChild);
</span><span class="cx"> fixEdge<Int52RepUse>(rightChild);
</span><span class="cx"> if (bytecodeCanIgnoreNegativeZero(node->arithNodeFlags())
</span><span class="lines">@@ -446,7 +446,7 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> if (enableInt52()
</span><del>- && Node::shouldSpeculateMachineInt(node->child1().node(), node->child2().node())) {
</del><ins>+ && Node::shouldSpeculateAnyInt(node->child1().node(), node->child2().node())) {
</ins><span class="cx"> fixEdge<Int52RepUse>(node->child1());
</span><span class="cx"> fixEdge<Int52RepUse>(node->child2());
</span><span class="cx"> node->clearFlags(NodeMustGenerate);
</span><span class="lines">@@ -551,7 +551,7 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> if (enableInt52()
</span><del>- && Node::shouldSpeculateMachineInt(node->child1().node(), node->child2().node())) {
</del><ins>+ && Node::shouldSpeculateAnyInt(node->child1().node(), node->child2().node())) {
</ins><span class="cx"> fixEdge<Int52RepUse>(node->child1());
</span><span class="cx"> fixEdge<Int52RepUse>(node->child2());
</span><span class="cx"> break;
</span><span class="lines">@@ -763,7 +763,7 @@
</span><span class="cx"> case Array::Uint32Array:
</span><span class="cx"> if (node->shouldSpeculateInt32())
</span><span class="cx"> break;
</span><del>- if (node->shouldSpeculateMachineInt() && enableInt52())
</del><ins>+ if (node->shouldSpeculateAnyInt() && enableInt52())
</ins><span class="cx"> node->setResult(NodeResultInt52);
</span><span class="cx"> else
</span><span class="cx"> node->setResult(NodeResultDouble);
</span><span class="lines">@@ -829,7 +829,7 @@
</span><span class="cx"> fixEdge<Int32Use>(child2);
</span><span class="cx"> if (child3->shouldSpeculateInt32())
</span><span class="cx"> fixIntOrBooleanEdge(child3);
</span><del>- else if (child3->shouldSpeculateMachineInt())
</del><ins>+ else if (child3->shouldSpeculateAnyInt())
</ins><span class="cx"> fixEdge<Int52RepUse>(child3);
</span><span class="cx"> else
</span><span class="cx"> fixDoubleOrBooleanEdge(child3);
</span><span class="lines">@@ -869,7 +869,7 @@
</span><span class="cx"> node->arrayMode().refine(
</span><span class="cx"> m_graph, node,
</span><span class="cx"> node->child1()->prediction() & SpecCell,
</span><del>- SpecInt32,
</del><ins>+ SpecInt32Only,
</ins><span class="cx"> node->child2()->prediction()));
</span><span class="cx"> blessArrayOperation(node->child1(), Edge(), node->child3());
</span><span class="cx"> fixEdge<KnownCellUse>(node->child1());
</span><span class="lines">@@ -1433,13 +1433,13 @@
</span><span class="cx">
</span><span class="cx"> RefPtr<TypeSet> typeSet = node->typeLocation()->m_instructionTypeSet;
</span><span class="cx"> RuntimeTypeMask seenTypes = typeSet->seenTypes();
</span><del>- if (typeSet->doesTypeConformTo(TypeMachineInt)) {
</del><ins>+ if (typeSet->doesTypeConformTo(TypeAnyInt)) {
</ins><span class="cx"> if (node->child1()->shouldSpeculateInt32())
</span><span class="cx"> fixEdge<Int32Use>(node->child1());
</span><span class="cx"> else
</span><del>- fixEdge<MachineIntUse>(node->child1());
</del><ins>+ fixEdge<AnyIntUse>(node->child1());
</ins><span class="cx"> node->remove();
</span><del>- } else if (typeSet->doesTypeConformTo(TypeNumber | TypeMachineInt)) {
</del><ins>+ } else if (typeSet->doesTypeConformTo(TypeNumber | TypeAnyInt)) {
</ins><span class="cx"> fixEdge<NumberUse>(node->child1());
</span><span class="cx"> node->remove();
</span><span class="cx"> } else if (typeSet->doesTypeConformTo(TypeString)) {
</span><span class="lines">@@ -1678,7 +1678,7 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (enableInt52() && node->child1()->shouldSpeculateMachineInt()) {
</del><ins>+ if (enableInt52() && node->child1()->shouldSpeculateAnyInt()) {
</ins><span class="cx"> fixEdge<Int52RepUse>(node->child1());
</span><span class="cx"> node->convertToIdentity();
</span><span class="cx"> node->setResult(NodeResultInt52);
</span><span class="lines">@@ -2032,7 +2032,7 @@
</span><span class="cx"> m_profitabilityChanged |= variable->mergeIsProfitableToUnbox(true);
</span><span class="cx"> break;
</span><span class="cx"> case Int52RepUse:
</span><del>- if (isMachineIntSpeculation(variable->prediction()))
</del><ins>+ if (isAnyIntSpeculation(variable->prediction()))
</ins><span class="cx"> m_profitabilityChanged |= variable->mergeIsProfitableToUnbox(true);
</span><span class="cx"> break;
</span><span class="cx"> case CellUse:
</span><span class="lines">@@ -2109,14 +2109,14 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> UseKind useKind;
</span><del>- if (node->shouldSpeculateMachineInt())
</del><ins>+ if (node->shouldSpeculateAnyInt())
</ins><span class="cx"> useKind = Int52RepUse;
</span><span class="cx"> else if (node->shouldSpeculateNumber())
</span><span class="cx"> useKind = DoubleRepUse;
</span><span class="cx"> else
</span><span class="cx"> useKind = NotCellUse;
</span><span class="cx"> Node* newNode = m_insertionSet.insertNode(
</span><del>- m_indexInBlock, SpecInt32, ValueToInt32, m_currentNode->origin,
</del><ins>+ m_indexInBlock, SpecInt32Only, ValueToInt32, m_currentNode->origin,
</ins><span class="cx"> Edge(node, useKind));
</span><span class="cx"> observeUseKindOnNode(node, useKind);
</span><span class="cx">
</span><span class="lines">@@ -2137,7 +2137,7 @@
</span><span class="cx"> else
</span><span class="cx"> useKind = UntypedUse;
</span><span class="cx"> Node* newNode = m_insertionSet.insertNode(
</span><del>- m_indexInBlock, SpecInt32, BooleanToNumber, m_currentNode->origin,
</del><ins>+ m_indexInBlock, SpecInt32Only, BooleanToNumber, m_currentNode->origin,
</ins><span class="cx"> Edge(node, useKind));
</span><span class="cx"> observeUseKindOnNode(node, useKind);
</span><span class="cx">
</span><span class="lines">@@ -2158,7 +2158,7 @@
</span><span class="cx"> else
</span><span class="cx"> useKind = UntypedUse;
</span><span class="cx"> Node* newNode = m_insertionSet.insertNode(
</span><del>- m_indexInBlock, SpecInt32, BooleanToNumber, m_currentNode->origin,
</del><ins>+ m_indexInBlock, SpecInt32Only, BooleanToNumber, m_currentNode->origin,
</ins><span class="cx"> Edge(node, useKind));
</span><span class="cx"> observeUseKindOnNode(node, useKind);
</span><span class="cx">
</span><span class="lines">@@ -2176,7 +2176,7 @@
</span><span class="cx"> value = jsNumber(JSC::toInt32(value.asNumber()));
</span><span class="cx"> ASSERT(value.isInt32());
</span><span class="cx"> edge.setNode(m_insertionSet.insertNode(
</span><del>- m_indexInBlock, SpecInt32, JSConstant, m_currentNode->origin,
</del><ins>+ m_indexInBlock, SpecInt32Only, JSConstant, m_currentNode->origin,
</ins><span class="cx"> OpInfo(m_graph.freeze(value))));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2206,7 +2206,7 @@
</span><span class="cx"> return true;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (m_graph.addShouldSpeculateMachineInt(node)) {
</del><ins>+ if (m_graph.addShouldSpeculateAnyInt(node)) {
</ins><span class="cx"> fixEdge<Int52RepUse>(node->child1());
</span><span class="cx"> fixEdge<Int52RepUse>(node->child2());
</span><span class="cx"> node->setArithMode(Arith::CheckOverflow);
</span><span class="lines">@@ -2279,7 +2279,7 @@
</span><span class="cx"> {
</span><span class="cx"> Node* storage = checkArray(arrayMode, origin, child, 0, lengthNeedsStorage);
</span><span class="cx"> return m_insertionSet.insertNode(
</span><del>- m_indexInBlock, SpecInt32, GetArrayLength, origin,
</del><ins>+ m_indexInBlock, SpecInt32Only, GetArrayLength, origin,
</ins><span class="cx"> OpInfo(arrayMode.asWord()), Edge(child, KnownCellUse), Edge(storage));
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2369,7 +2369,7 @@
</span><span class="cx"> switch (edge.useKind()) {
</span><span class="cx"> case DoubleRepUse:
</span><span class="cx"> case DoubleRepRealUse:
</span><del>- case DoubleRepMachineIntUse: {
</del><ins>+ case DoubleRepAnyIntUse: {
</ins><span class="cx"> if (edge->hasDoubleResult())
</span><span class="cx"> break;
</span><span class="cx">
</span><span class="lines">@@ -2379,7 +2379,7 @@
</span><span class="cx"> OpInfo(m_graph.freeze(jsDoubleNumber(edge->asNumber()))));
</span><span class="cx"> } else if (edge->hasInt52Result()) {
</span><span class="cx"> result = m_insertionSet.insertNode(
</span><del>- indexForChecks, SpecInt52AsDouble, DoubleRep, originForChecks,
</del><ins>+ indexForChecks, SpecAnyIntAsDouble, DoubleRep, originForChecks,
</ins><span class="cx"> Edge(edge.node(), Int52RepUse));
</span><span class="cx"> } else {
</span><span class="cx"> UseKind useKind;
</span><span class="lines">@@ -2403,22 +2403,22 @@
</span><span class="cx"> if (edge->hasInt52Result())
</span><span class="cx"> break;
</span><span class="cx">
</span><del>- if (edge->isMachineIntConstant()) {
</del><ins>+ if (edge->isAnyIntConstant()) {
</ins><span class="cx"> result = m_insertionSet.insertNode(
</span><del>- indexForChecks, SpecMachineInt, Int52Constant, originForChecks,
</del><ins>+ indexForChecks, SpecAnyInt, Int52Constant, originForChecks,
</ins><span class="cx"> OpInfo(edge->constant()));
</span><span class="cx"> } else if (edge->hasDoubleResult()) {
</span><span class="cx"> result = m_insertionSet.insertNode(
</span><del>- indexForChecks, SpecMachineInt, Int52Rep, originForChecks,
- Edge(edge.node(), DoubleRepMachineIntUse));
</del><ins>+ indexForChecks, SpecAnyInt, Int52Rep, originForChecks,
+ Edge(edge.node(), DoubleRepAnyIntUse));
</ins><span class="cx"> } else if (edge->shouldSpeculateInt32ForArithmetic()) {
</span><span class="cx"> result = m_insertionSet.insertNode(
</span><del>- indexForChecks, SpecInt32, Int52Rep, originForChecks,
</del><ins>+ indexForChecks, SpecInt32Only, Int52Rep, originForChecks,
</ins><span class="cx"> Edge(edge.node(), Int32Use));
</span><span class="cx"> } else {
</span><span class="cx"> result = m_insertionSet.insertNode(
</span><del>- indexForChecks, SpecMachineInt, Int52Rep, originForChecks,
- Edge(edge.node(), MachineIntUse));
</del><ins>+ indexForChecks, SpecAnyInt, Int52Rep, originForChecks,
+ Edge(edge.node(), AnyIntUse));
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> edge.setNode(result);
</span><span class="lines">@@ -2435,7 +2435,7 @@
</span><span class="cx"> Edge(edge.node(), DoubleRepUse));
</span><span class="cx"> } else {
</span><span class="cx"> result = m_insertionSet.insertNode(
</span><del>- indexForChecks, SpecInt32 | SpecInt52AsDouble, ValueRep,
</del><ins>+ indexForChecks, SpecInt32Only | SpecAnyIntAsDouble, ValueRep,
</ins><span class="cx"> originForChecks, Edge(edge.node(), Int52RepUse));
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGGraphh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGGraph.h (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGGraph.h 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGGraph.h 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -263,7 +263,7 @@
</span><span class="cx"> return addSpeculationMode(add, pass) != DontSpeculateInt32;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- bool addShouldSpeculateMachineInt(Node* add)
</del><ins>+ bool addShouldSpeculateAnyInt(Node* add)
</ins><span class="cx"> {
</span><span class="cx"> if (!enableInt52())
</span><span class="cx"> return false;
</span><span class="lines">@@ -271,7 +271,7 @@
</span><span class="cx"> Node* left = add->child1().node();
</span><span class="cx"> Node* right = add->child2().node();
</span><span class="cx">
</span><del>- bool speculation = Node::shouldSpeculateMachineInt(left, right);
</del><ins>+ bool speculation = Node::shouldSpeculateAnyInt(left, right);
</ins><span class="cx"> return speculation && !hasExitSite(add, Int52Overflow);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -284,7 +284,7 @@
</span><span class="cx"> && node->canSpeculateInt32(node->sourceFor(pass));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- bool binaryArithShouldSpeculateMachineInt(Node* node, PredictionPass pass)
</del><ins>+ bool binaryArithShouldSpeculateAnyInt(Node* node, PredictionPass pass)
</ins><span class="cx"> {
</span><span class="cx"> if (!enableInt52())
</span><span class="cx"> return false;
</span><span class="lines">@@ -292,7 +292,7 @@
</span><span class="cx"> Node* left = node->child1().node();
</span><span class="cx"> Node* right = node->child2().node();
</span><span class="cx">
</span><del>- return Node::shouldSpeculateMachineInt(left, right)
</del><ins>+ return Node::shouldSpeculateAnyInt(left, right)
</ins><span class="cx"> && node->canSpeculateInt52(pass)
</span><span class="cx"> && !hasExitSite(node, Int52Overflow);
</span><span class="cx"> }
</span><span class="lines">@@ -303,11 +303,11 @@
</span><span class="cx"> && node->canSpeculateInt32(pass);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- bool unaryArithShouldSpeculateMachineInt(Node* node, PredictionPass pass)
</del><ins>+ bool unaryArithShouldSpeculateAnyInt(Node* node, PredictionPass pass)
</ins><span class="cx"> {
</span><span class="cx"> if (!enableInt52())
</span><span class="cx"> return false;
</span><del>- return node->child1()->shouldSpeculateMachineInt()
</del><ins>+ return node->child1()->shouldSpeculateAnyInt()
</ins><span class="cx"> && node->canSpeculateInt52(pass)
</span><span class="cx"> && !hasExitSite(node, Int52Overflow);
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGInPlaceAbstractStatecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGInPlaceAbstractState.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGInPlaceAbstractState.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGInPlaceAbstractState.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -118,7 +118,7 @@
</span><span class="cx">
</span><span class="cx"> switch (format) {
</span><span class="cx"> case FlushedInt32:
</span><del>- root->valuesAtHead.argument(i).setType(SpecInt32);
</del><ins>+ root->valuesAtHead.argument(i).setType(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case FlushedBoolean:
</span><span class="cx"> root->valuesAtHead.argument(i).setType(SpecBoolean);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGJITCompilercpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -542,7 +542,7 @@
</span><span class="cx"> entry->m_localsForcedDouble.set(local);
</span><span class="cx"> break;
</span><span class="cx"> case FlushedInt52:
</span><del>- entry->m_localsForcedMachineInt.set(local);
</del><ins>+ entry->m_localsForcedAnyInt.set(local);
</ins><span class="cx"> break;
</span><span class="cx"> default:
</span><span class="cx"> break;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGNodecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGNode.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGNode.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGNode.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -132,10 +132,10 @@
</span><span class="cx"> setOpAndDefaultFlags(Int52Rep);
</span><span class="cx"> switch (input) {
</span><span class="cx"> case NodeResultDouble:
</span><del>- child1().setUseKind(DoubleRepMachineIntUse);
</del><ins>+ child1().setUseKind(DoubleRepAnyIntUse);
</ins><span class="cx"> return;
</span><span class="cx"> case NodeResultJS:
</span><del>- child1().setUseKind(MachineIntUse);
</del><ins>+ child1().setUseKind(AnyIntUse);
</ins><span class="cx"> return;
</span><span class="cx"> default:
</span><span class="cx"> RELEASE_ASSERT_NOT_REACHED();
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGNodeh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGNode.h (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGNode.h 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGNode.h 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -681,14 +681,14 @@
</span><span class="cx"> return asJSValue().asNumber();
</span><span class="cx"> }
</span><span class="cx">
</span><del>- bool isMachineIntConstant()
</del><ins>+ bool isAnyIntConstant()
</ins><span class="cx"> {
</span><del>- return isConstant() && constant()->value().isMachineInt();
</del><ins>+ return isConstant() && constant()->value().isAnyInt();
</ins><span class="cx"> }
</span><span class="cx">
</span><del>- int64_t asMachineInt()
</del><ins>+ int64_t asAnyInt()
</ins><span class="cx"> {
</span><del>- return asJSValue().asMachineInt();
</del><ins>+ return asJSValue().asAnyInt();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool isBooleanConstant()
</span><span class="lines">@@ -1920,9 +1920,9 @@
</span><span class="cx"> return isInt32OrBooleanSpeculationExpectingDefined(prediction());
</span><span class="cx"> }
</span><span class="cx">
</span><del>- bool shouldSpeculateMachineInt()
</del><ins>+ bool shouldSpeculateAnyInt()
</ins><span class="cx"> {
</span><del>- return isMachineIntSpeculation(prediction());
</del><ins>+ return isAnyIntSpeculation(prediction());
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> bool shouldSpeculateDouble()
</span><span class="lines">@@ -2153,9 +2153,9 @@
</span><span class="cx"> && op2->shouldSpeculateInt32OrBooleanExpectingDefined();
</span><span class="cx"> }
</span><span class="cx">
</span><del>- static bool shouldSpeculateMachineInt(Node* op1, Node* op2)
</del><ins>+ static bool shouldSpeculateAnyInt(Node* op1, Node* op2)
</ins><span class="cx"> {
</span><del>- return op1->shouldSpeculateMachineInt() && op2->shouldSpeculateMachineInt();
</del><ins>+ return op1->shouldSpeculateAnyInt() && op2->shouldSpeculateAnyInt();
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> static bool shouldSpeculateNumber(Node* op1, Node* op2)
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGOSREntrycpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGOSREntry.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGOSREntry.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGOSREntry.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -67,7 +67,7 @@
</span><span class="cx"> out.print("overwritten");
</span><span class="cx"> if (reg.isLocal() && m_localsForcedDouble.get(reg.toLocal()))
</span><span class="cx"> out.print(", forced double");
</span><del>- if (reg.isLocal() && m_localsForcedMachineInt.get(reg.toLocal()))
</del><ins>+ if (reg.isLocal() && m_localsForcedAnyInt.get(reg.toLocal()))
</ins><span class="cx"> out.print(", forced machine int");
</span><span class="cx"> out.print(")");
</span><span class="cx"> };
</span><span class="lines">@@ -213,8 +213,8 @@
</span><span class="cx"> }
</span><span class="cx"> continue;
</span><span class="cx"> }
</span><del>- if (entry->m_localsForcedMachineInt.get(local)) {
- if (!exec->registers()[localOffset].asanUnsafeJSValue().isMachineInt()) {
</del><ins>+ if (entry->m_localsForcedAnyInt.get(local)) {
+ if (!exec->registers()[localOffset].asanUnsafeJSValue().isAnyInt()) {
</ins><span class="cx"> if (Options::verboseOSR()) {
</span><span class="cx"> dataLog(
</span><span class="cx"> " OSR failed because variable ", localOffset, " is ",
</span><span class="lines">@@ -285,8 +285,8 @@
</span><span class="cx"> continue;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (entry->m_localsForcedMachineInt.get(reg.toLocal())) {
- *bitwise_cast<int64_t*>(pivot + index) = exec->registers()[reg.offset()].asanUnsafeJSValue().asMachineInt() << JSValue::int52ShiftAmount;
</del><ins>+ if (entry->m_localsForcedAnyInt.get(reg.toLocal())) {
+ *bitwise_cast<int64_t*>(pivot + index) = exec->registers()[reg.offset()].asanUnsafeJSValue().asAnyInt() << JSValue::int52ShiftAmount;
</ins><span class="cx"> continue;
</span><span class="cx"> }
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGOSREntryh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGOSREntry.h (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGOSREntry.h 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGOSREntry.h 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -57,7 +57,7 @@
</span><span class="cx"> Operands<AbstractValue> m_expectedValues;
</span><span class="cx"> // Use bitvectors here because they tend to only require one word.
</span><span class="cx"> BitVector m_localsForcedDouble;
</span><del>- BitVector m_localsForcedMachineInt;
</del><ins>+ BitVector m_localsForcedAnyInt;
</ins><span class="cx"> Vector<OSREntryReshuffling> m_reshufflings;
</span><span class="cx"> BitVector m_machineStackUsed;
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGPredictionPropagationPhasecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -155,8 +155,8 @@
</span><span class="cx"> case GetLocal: {
</span><span class="cx"> VariableAccessData* variable = node->variableAccessData();
</span><span class="cx"> SpeculatedType prediction = variable->prediction();
</span><del>- if (!variable->couldRepresentInt52() && (prediction & SpecInt52))
- prediction = (prediction | SpecInt52AsDouble) & ~SpecInt52;
</del><ins>+ if (!variable->couldRepresentInt52() && (prediction & SpecInt52Only))
+ prediction = (prediction | SpecAnyIntAsDouble) & ~SpecInt52Only;
</ins><span class="cx"> if (prediction)
</span><span class="cx"> changed |= mergePrediction(prediction);
</span><span class="cx"> break;
</span><span class="lines">@@ -170,9 +170,9 @@
</span><span class="cx">
</span><span class="cx"> case UInt32ToNumber: {
</span><span class="cx"> if (node->canSpeculateInt32(m_pass))
</span><del>- changed |= mergePrediction(SpecInt32);
</del><ins>+ changed |= mergePrediction(SpecInt32Only);
</ins><span class="cx"> else if (enableInt52())
</span><del>- changed |= mergePrediction(SpecMachineInt);
</del><ins>+ changed |= mergePrediction(SpecAnyInt);
</ins><span class="cx"> else
</span><span class="cx"> changed |= mergePrediction(SpecBytecodeNumber);
</span><span class="cx"> break;
</span><span class="lines">@@ -186,9 +186,9 @@
</span><span class="cx"> if (isFullNumberOrBooleanSpeculationExpectingDefined(left)
</span><span class="cx"> && isFullNumberOrBooleanSpeculationExpectingDefined(right)) {
</span><span class="cx"> if (m_graph.addSpeculationMode(node, m_pass) != DontSpeculateInt32)
</span><del>- changed |= mergePrediction(SpecInt32);
- else if (m_graph.addShouldSpeculateMachineInt(node))
- changed |= mergePrediction(SpecInt52);
</del><ins>+ changed |= mergePrediction(SpecInt32Only);
+ else if (m_graph.addShouldSpeculateAnyInt(node))
+ changed |= mergePrediction(SpecInt52Only);
</ins><span class="cx"> else
</span><span class="cx"> changed |= mergePrediction(speculatedDoubleTypeForPredictions(left, right));
</span><span class="cx"> } else if (
</span><span class="lines">@@ -197,7 +197,7 @@
</span><span class="cx"> // left or right is definitely something other than a number.
</span><span class="cx"> changed |= mergePrediction(SpecString);
</span><span class="cx"> } else
</span><del>- changed |= mergePrediction(SpecString | SpecInt32 | SpecBytecodeDouble);
</del><ins>+ changed |= mergePrediction(SpecString | SpecInt32Only | SpecBytecodeDouble);
</ins><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="lines">@@ -208,9 +208,9 @@
</span><span class="cx">
</span><span class="cx"> if (left && right) {
</span><span class="cx"> if (m_graph.addSpeculationMode(node, m_pass) != DontSpeculateInt32)
</span><del>- changed |= mergePrediction(SpecInt32);
- else if (m_graph.addShouldSpeculateMachineInt(node))
- changed |= mergePrediction(SpecInt52);
</del><ins>+ changed |= mergePrediction(SpecInt32Only);
+ else if (m_graph.addShouldSpeculateAnyInt(node))
+ changed |= mergePrediction(SpecInt52Only);
</ins><span class="cx"> else
</span><span class="cx"> changed |= mergePrediction(speculatedDoubleTypeForPredictions(left, right));
</span><span class="cx"> }
</span><span class="lines">@@ -225,13 +225,13 @@
</span><span class="cx"> if (isFullNumberOrBooleanSpeculationExpectingDefined(left)
</span><span class="cx"> && isFullNumberOrBooleanSpeculationExpectingDefined(right)) {
</span><span class="cx"> if (m_graph.addSpeculationMode(node, m_pass) != DontSpeculateInt32)
</span><del>- changed |= mergePrediction(SpecInt32);
- else if (m_graph.addShouldSpeculateMachineInt(node))
- changed |= mergePrediction(SpecInt52);
</del><ins>+ changed |= mergePrediction(SpecInt32Only);
+ else if (m_graph.addShouldSpeculateAnyInt(node))
+ changed |= mergePrediction(SpecInt52Only);
</ins><span class="cx"> else
</span><span class="cx"> changed |= mergePrediction(speculatedDoubleTypeForPredictions(left, right));
</span><span class="cx"> } else
</span><del>- changed |= mergePrediction(SpecInt32 | SpecBytecodeDouble);
</del><ins>+ changed |= mergePrediction(SpecInt32Only | SpecBytecodeDouble);
</ins><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="lines">@@ -239,9 +239,9 @@
</span><span class="cx"> case ArithNegate:
</span><span class="cx"> if (node->child1()->prediction()) {
</span><span class="cx"> if (m_graph.unaryArithShouldSpeculateInt32(node, m_pass))
</span><del>- changed |= mergePrediction(SpecInt32);
- else if (m_graph.unaryArithShouldSpeculateMachineInt(node, m_pass))
- changed |= mergePrediction(SpecInt52);
</del><ins>+ changed |= mergePrediction(SpecInt32Only);
+ else if (m_graph.unaryArithShouldSpeculateAnyInt(node, m_pass))
+ changed |= mergePrediction(SpecInt52Only);
</ins><span class="cx"> else
</span><span class="cx"> changed |= mergePrediction(speculatedDoubleTypeForPrediction(node->child1()->prediction()));
</span><span class="cx"> }
</span><span class="lines">@@ -255,7 +255,7 @@
</span><span class="cx"> if (left && right) {
</span><span class="cx"> if (Node::shouldSpeculateInt32OrBooleanForArithmetic(node->child1().node(), node->child2().node())
</span><span class="cx"> && node->canSpeculateInt32(m_pass))
</span><del>- changed |= mergePrediction(SpecInt32);
</del><ins>+ changed |= mergePrediction(SpecInt32Only);
</ins><span class="cx"> else
</span><span class="cx"> changed |= mergePrediction(speculatedDoubleTypeForPredictions(left, right));
</span><span class="cx"> }
</span><span class="lines">@@ -270,16 +270,16 @@
</span><span class="cx"> if (isFullNumberOrBooleanSpeculationExpectingDefined(left)
</span><span class="cx"> && isFullNumberOrBooleanSpeculationExpectingDefined(right)) {
</span><span class="cx"> if (m_graph.binaryArithShouldSpeculateInt32(node, m_pass))
</span><del>- changed |= mergePrediction(SpecInt32);
- else if (m_graph.binaryArithShouldSpeculateMachineInt(node, m_pass))
- changed |= mergePrediction(SpecInt52);
</del><ins>+ changed |= mergePrediction(SpecInt32Only);
+ else if (m_graph.binaryArithShouldSpeculateAnyInt(node, m_pass))
+ changed |= mergePrediction(SpecInt52Only);
</ins><span class="cx"> else
</span><span class="cx"> changed |= mergePrediction(speculatedDoubleTypeForPredictions(left, right));
</span><span class="cx"> } else {
</span><span class="cx"> if (node->mayHaveNonIntResult())
</span><del>- changed |= mergePrediction(SpecInt32 | SpecBytecodeDouble);
</del><ins>+ changed |= mergePrediction(SpecInt32Only | SpecBytecodeDouble);
</ins><span class="cx"> else
</span><del>- changed |= mergePrediction(SpecInt32);
</del><ins>+ changed |= mergePrediction(SpecInt32Only);
</ins><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx"> break;
</span><span class="lines">@@ -294,11 +294,11 @@
</span><span class="cx"> if (isFullNumberOrBooleanSpeculationExpectingDefined(left)
</span><span class="cx"> && isFullNumberOrBooleanSpeculationExpectingDefined(right)) {
</span><span class="cx"> if (m_graph.binaryArithShouldSpeculateInt32(node, m_pass))
</span><del>- changed |= mergePrediction(SpecInt32);
</del><ins>+ changed |= mergePrediction(SpecInt32Only);
</ins><span class="cx"> else
</span><span class="cx"> changed |= mergePrediction(SpecBytecodeDouble);
</span><span class="cx"> } else
</span><del>- changed |= mergePrediction(SpecInt32 | SpecBytecodeDouble);
</del><ins>+ changed |= mergePrediction(SpecInt32Only | SpecBytecodeDouble);
</ins><span class="cx"> }
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="lines">@@ -308,7 +308,7 @@
</span><span class="cx"> case ArithCeil:
</span><span class="cx"> case ArithTrunc: {
</span><span class="cx"> if (isInt32OrBooleanSpeculation(node->getHeapPrediction()) && m_graph.roundShouldSpeculateInt32(node, m_pass))
</span><del>- changed |= setPrediction(SpecInt32);
</del><ins>+ changed |= setPrediction(SpecInt32Only);
</ins><span class="cx"> else
</span><span class="cx"> changed |= setPrediction(SpecBytecodeDouble);
</span><span class="cx"> break;
</span><span class="lines">@@ -318,7 +318,7 @@
</span><span class="cx"> SpeculatedType child = node->child1()->prediction();
</span><span class="cx"> if (isInt32OrBooleanSpeculationForArithmetic(child)
</span><span class="cx"> && node->canSpeculateInt32(m_pass))
</span><del>- changed |= mergePrediction(SpecInt32);
</del><ins>+ changed |= mergePrediction(SpecInt32Only);
</ins><span class="cx"> else
</span><span class="cx"> changed |= mergePrediction(speculatedDoubleTypeForPrediction(child));
</span><span class="cx"> break;
</span><span class="lines">@@ -337,9 +337,9 @@
</span><span class="cx"> switch (arrayMode.type()) {
</span><span class="cx"> case Array::Int32:
</span><span class="cx"> if (arrayMode.isOutOfBounds())
</span><del>- changed |= mergePrediction(node->getHeapPrediction() | SpecInt32);
</del><ins>+ changed |= mergePrediction(node->getHeapPrediction() | SpecInt32Only);
</ins><span class="cx"> else
</span><del>- changed |= mergePrediction(SpecInt32);
</del><ins>+ changed |= mergePrediction(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> case Array::Double:
</span><span class="cx"> if (arrayMode.isOutOfBounds())
</span><span class="lines">@@ -353,18 +353,18 @@
</span><span class="cx"> break;
</span><span class="cx"> case Array::Uint32Array:
</span><span class="cx"> if (isInt32SpeculationForArithmetic(node->getHeapPrediction()))
</span><del>- changed |= mergePrediction(SpecInt32);
</del><ins>+ changed |= mergePrediction(SpecInt32Only);
</ins><span class="cx"> else if (enableInt52())
</span><del>- changed |= mergePrediction(SpecMachineInt);
</del><ins>+ changed |= mergePrediction(SpecAnyInt);
</ins><span class="cx"> else
</span><del>- changed |= mergePrediction(SpecInt32 | SpecInt52AsDouble);
</del><ins>+ changed |= mergePrediction(SpecInt32Only | SpecAnyIntAsDouble);
</ins><span class="cx"> break;
</span><span class="cx"> case Array::Int8Array:
</span><span class="cx"> case Array::Uint8Array:
</span><span class="cx"> case Array::Int16Array:
</span><span class="cx"> case Array::Uint16Array:
</span><span class="cx"> case Array::Int32Array:
</span><del>- changed |= mergePrediction(SpecInt32);
</del><ins>+ changed |= mergePrediction(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> default:
</span><span class="cx"> changed |= mergePrediction(node->getHeapPrediction());
</span><span class="lines">@@ -383,17 +383,17 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (node->child1()->shouldSpeculateInt32()) {
</span><del>- changed |= mergePrediction(SpecInt32);
</del><ins>+ changed |= mergePrediction(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (enableInt52() && node->child1()->shouldSpeculateMachineInt()) {
- changed |= mergePrediction(SpecMachineInt);
</del><ins>+ if (enableInt52() && node->child1()->shouldSpeculateAnyInt()) {
+ changed |= mergePrediction(SpecAnyInt);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (node->child1()->shouldSpeculateNumber()) {
</span><del>- changed |= mergePrediction(SpecMachineInt);
</del><ins>+ changed |= mergePrediction(SpecAnyInt);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -482,7 +482,7 @@
</span><span class="cx"> if (isFullNumberSpeculation(left)
</span><span class="cx"> && isFullNumberSpeculation(right)
</span><span class="cx"> && !m_graph.addShouldSpeculateInt32(node, m_pass)
</span><del>- && !m_graph.addShouldSpeculateMachineInt(node))
</del><ins>+ && !m_graph.addShouldSpeculateAnyInt(node))
</ins><span class="cx"> ballot = VoteDouble;
</span><span class="cx"> else
</span><span class="cx"> ballot = VoteValue;
</span><span class="lines">@@ -501,7 +501,7 @@
</span><span class="cx"> if (isFullNumberSpeculation(left)
</span><span class="cx"> && isFullNumberSpeculation(right)
</span><span class="cx"> && !m_graph.binaryArithShouldSpeculateInt32(node, m_pass)
</span><del>- && !m_graph.binaryArithShouldSpeculateMachineInt(node, m_pass))
</del><ins>+ && !m_graph.binaryArithShouldSpeculateAnyInt(node, m_pass))
</ins><span class="cx"> ballot = VoteDouble;
</span><span class="cx"> else
</span><span class="cx"> ballot = VoteValue;
</span><span class="lines">@@ -558,7 +558,7 @@
</span><span class="cx"> if (isDoubleSpeculation(prediction))
</span><span class="cx"> node->variableAccessData()->vote(VoteDouble, weight);
</span><span class="cx"> else if (!isFullNumberSpeculation(prediction)
</span><del>- || isInt32Speculation(prediction) || isMachineIntSpeculation(prediction))
</del><ins>+ || isInt32Speculation(prediction) || isAnyIntSpeculation(prediction))
</ins><span class="cx"> node->variableAccessData()->vote(VoteValue, weight);
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="lines">@@ -643,8 +643,8 @@
</span><span class="cx"> switch (m_currentNode->op()) {
</span><span class="cx"> case JSConstant: {
</span><span class="cx"> SpeculatedType type = speculationFromValue(m_currentNode->asJSValue());
</span><del>- if (type == SpecInt52AsDouble && enableInt52())
- type = SpecInt52;
</del><ins>+ if (type == SpecAnyIntAsDouble && enableInt52())
+ type = SpecInt52Only;
</ins><span class="cx"> setPrediction(type);
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="lines">@@ -661,7 +661,7 @@
</span><span class="cx"> case BitURShift:
</span><span class="cx"> case ArithIMul:
</span><span class="cx"> case ArithClz32: {
</span><del>- setPrediction(SpecInt32);
</del><ins>+ setPrediction(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -717,23 +717,23 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> case GetArgumentCount: {
</span><del>- setPrediction(SpecInt32);
</del><ins>+ setPrediction(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> case GetRestLength: {
</span><del>- setPrediction(SpecInt32);
</del><ins>+ setPrediction(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> case GetTypedArrayByteOffset:
</span><span class="cx"> case GetArrayLength: {
</span><del>- setPrediction(SpecInt32);
</del><ins>+ setPrediction(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> case StringCharCodeAt: {
</span><del>- setPrediction(SpecInt32);
</del><ins>+ setPrediction(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case ArithPow:
</span><span class="lines">@@ -866,7 +866,7 @@
</span><span class="cx">
</span><span class="cx"> case FiatInt52: {
</span><span class="cx"> RELEASE_ASSERT(enableInt52());
</span><del>- setPrediction(SpecMachineInt);
</del><ins>+ setPrediction(SpecAnyInt);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -879,7 +879,7 @@
</span><span class="cx"> break;
</span><span class="cx">
</span><span class="cx"> case GetEnumerableLength: {
</span><del>- setPrediction(SpecInt32);
</del><ins>+ setPrediction(SpecInt32Only);
</ins><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case HasGenericProperty:
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGSSALoweringPhasecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGSSALoweringPhase.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGSSALoweringPhase.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGSSALoweringPhase.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -83,7 +83,7 @@
</span><span class="cx">
</span><span class="cx"> if (m_node->arrayMode().typedArrayType() != NotTypedArray && m_node->arrayMode().isOutOfBounds()) {
</span><span class="cx"> Node* length = m_insertionSet.insertNode(
</span><del>- m_nodeIndex, SpecInt32, GetArrayLength, m_node->origin,
</del><ins>+ m_nodeIndex, SpecInt32Only, GetArrayLength, m_node->origin,
</ins><span class="cx"> OpInfo(m_node->arrayMode().asWord()), base, storage);
</span><span class="cx">
</span><span class="cx"> m_graph.varArgChild(m_node, 4) = Edge(length, KnownInt32Use);
</span><span class="lines">@@ -106,10 +106,10 @@
</span><span class="cx"> storage = Edge();
</span><span class="cx">
</span><span class="cx"> Node* length = m_insertionSet.insertNode(
</span><del>- m_nodeIndex, SpecInt32, GetArrayLength, m_node->origin,
</del><ins>+ m_nodeIndex, SpecInt32Only, GetArrayLength, m_node->origin,
</ins><span class="cx"> OpInfo(m_node->arrayMode().asWord()), base, storage);
</span><span class="cx"> m_insertionSet.insertNode(
</span><del>- m_nodeIndex, SpecInt32, CheckInBounds, m_node->origin,
</del><ins>+ m_nodeIndex, SpecInt32Only, CheckInBounds, m_node->origin,
</ins><span class="cx"> index, Edge(length, KnownInt32Use));
</span><span class="cx"> return true;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGSafeToExecuteh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGSafeToExecute.h (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGSafeToExecute.h 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGSafeToExecute.h 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -69,12 +69,12 @@
</span><span class="cx"> case NotCellUse:
</span><span class="cx"> case OtherUse:
</span><span class="cx"> case MiscUse:
</span><del>- case MachineIntUse:
- case DoubleRepMachineIntUse:
</del><ins>+ case AnyIntUse:
+ case DoubleRepAnyIntUse:
</ins><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> case KnownInt32Use:
</span><del>- if (m_state.forNode(edge).m_type & ~SpecInt32)
</del><ins>+ if (m_state.forNode(edge).m_type & ~SpecInt32Only)
</ins><span class="cx"> m_result = false;
</span><span class="cx"> return;
</span><span class="cx">
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGSpeculativeJITcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -609,10 +609,10 @@
</span><span class="cx"> break;
</span><span class="cx"> #if USE(JSVALUE64)
</span><span class="cx"> case SetInt52Constant:
</span><del>- m_jit.move(Imm64(plan.node()->asMachineInt() << JSValue::int52ShiftAmount), plan.gpr());
</del><ins>+ m_jit.move(Imm64(plan.node()->asAnyInt() << JSValue::int52ShiftAmount), plan.gpr());
</ins><span class="cx"> break;
</span><span class="cx"> case SetStrictInt52Constant:
</span><del>- m_jit.move(Imm64(plan.node()->asMachineInt()), plan.gpr());
</del><ins>+ m_jit.move(Imm64(plan.node()->asAnyInt()), plan.gpr());
</ins><span class="cx"> break;
</span><span class="cx"> #endif // USE(JSVALUE64)
</span><span class="cx"> case SetBooleanConstant:
</span><span class="lines">@@ -2636,7 +2636,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> #if USE(JSVALUE64)
</span><del>- if (node->shouldSpeculateMachineInt()) {
</del><ins>+ if (node->shouldSpeculateAnyInt()) {
</ins><span class="cx"> m_jit.zeroExtend32ToPtr(resultReg, resultReg);
</span><span class="cx"> strictInt52Result(resultReg, node);
</span><span class="cx"> return;
</span><span class="lines">@@ -3561,8 +3561,8 @@
</span><span class="cx">
</span><span class="cx"> // Will we need an overflow check? If we can prove that neither input can be
</span><span class="cx"> // Int52 then the overflow check will not be necessary.
</span><del>- if (!m_state.forNode(node->child1()).couldBeType(SpecInt52)
- && !m_state.forNode(node->child2()).couldBeType(SpecInt52)) {
</del><ins>+ if (!m_state.forNode(node->child1()).couldBeType(SpecInt52Only)
+ && !m_state.forNode(node->child2()).couldBeType(SpecInt52Only)) {
</ins><span class="cx"> SpeculateWhicheverInt52Operand op1(this, node->child1());
</span><span class="cx"> SpeculateWhicheverInt52Operand op2(this, node->child2(), op1);
</span><span class="cx"> GPRTemporary result(this, Reuse, op1);
</span><span class="lines">@@ -3753,8 +3753,8 @@
</span><span class="cx">
</span><span class="cx"> // Will we need an overflow check? If we can prove that neither input can be
</span><span class="cx"> // Int52 then the overflow check will not be necessary.
</span><del>- if (!m_state.forNode(node->child1()).couldBeType(SpecInt52)
- && !m_state.forNode(node->child2()).couldBeType(SpecInt52)) {
</del><ins>+ if (!m_state.forNode(node->child1()).couldBeType(SpecInt52Only)
+ && !m_state.forNode(node->child2()).couldBeType(SpecInt52Only)) {
</ins><span class="cx"> SpeculateWhicheverInt52Operand op1(this, node->child1());
</span><span class="cx"> SpeculateWhicheverInt52Operand op2(this, node->child2(), op1);
</span><span class="cx"> GPRTemporary result(this, Reuse, op1);
</span><span class="lines">@@ -3875,7 +3875,7 @@
</span><span class="cx"> case Int52RepUse: {
</span><span class="cx"> ASSERT(shouldCheckOverflow(node->arithMode()));
</span><span class="cx">
</span><del>- if (!m_state.forNode(node->child1()).couldBeType(SpecInt52)) {
</del><ins>+ if (!m_state.forNode(node->child1()).couldBeType(SpecInt52Only)) {
</ins><span class="cx"> SpeculateWhicheverInt52Operand op1(this, node->child1());
</span><span class="cx"> GPRTemporary result(this);
</span><span class="cx"> GPRReg op1GPR = op1.gpr();
</span><span class="lines">@@ -6900,7 +6900,7 @@
</span><span class="cx">
</span><span class="cx"> void SpeculativeJIT::speculateInt32(Edge edge)
</span><span class="cx"> {
</span><del>- if (!needsTypeCheck(edge, SpecInt32))
</del><ins>+ if (!needsTypeCheck(edge, SpecInt32Only))
</ins><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> (SpeculateInt32Operand(this, edge)).gpr();
</span><span class="lines">@@ -6920,7 +6920,7 @@
</span><span class="cx"> #else
</span><span class="cx"> GPRReg tagGPR = value.tagGPR();
</span><span class="cx"> DFG_TYPE_CHECK(
</span><del>- value.jsValueRegs(), edge, ~SpecInt32,
</del><ins>+ value.jsValueRegs(), edge, ~SpecInt32Only,
</ins><span class="cx"> m_jit.branch32(MacroAssembler::Equal, tagGPR, TrustedImm32(JSValue::Int32Tag)));
</span><span class="cx"> DFG_TYPE_CHECK(
</span><span class="cx"> value.jsValueRegs(), edge, SpecBytecodeNumber,
</span><span class="lines">@@ -7248,7 +7248,7 @@
</span><span class="cx"> m_jit.branch64(MacroAssembler::Above, regs.gpr(), MacroAssembler::TrustedImm64(TagBitTypeOther | TagBitBool | TagBitUndefined)));
</span><span class="cx"> #else
</span><span class="cx"> DFG_TYPE_CHECK(
</span><del>- regs, edge, ~SpecInt32,
</del><ins>+ regs, edge, ~SpecInt32Only,
</ins><span class="cx"> m_jit.branch32(MacroAssembler::Equal, regs.tagGPR(), MacroAssembler::TrustedImm32(JSValue::Int32Tag)));
</span><span class="cx"> DFG_TYPE_CHECK(
</span><span class="cx"> regs, edge, SpecMisc,
</span><span class="lines">@@ -7271,13 +7271,13 @@
</span><span class="cx"> case UntypedUse:
</span><span class="cx"> break;
</span><span class="cx"> case KnownInt32Use:
</span><del>- ASSERT(!needsTypeCheck(edge, SpecInt32));
</del><ins>+ ASSERT(!needsTypeCheck(edge, SpecInt32Only));
</ins><span class="cx"> break;
</span><span class="cx"> case DoubleRepUse:
</span><span class="cx"> ASSERT(!needsTypeCheck(edge, SpecFullDouble));
</span><span class="cx"> break;
</span><span class="cx"> case Int52RepUse:
</span><del>- ASSERT(!needsTypeCheck(edge, SpecMachineInt));
</del><ins>+ ASSERT(!needsTypeCheck(edge, SpecAnyInt));
</ins><span class="cx"> break;
</span><span class="cx"> case KnownCellUse:
</span><span class="cx"> ASSERT(!needsTypeCheck(edge, SpecCell));
</span><span class="lines">@@ -7301,11 +7301,11 @@
</span><span class="cx"> speculateDoubleRepReal(edge);
</span><span class="cx"> break;
</span><span class="cx"> #if USE(JSVALUE64)
</span><del>- case MachineIntUse:
- speculateMachineInt(edge);
</del><ins>+ case AnyIntUse:
+ speculateAnyInt(edge);
</ins><span class="cx"> break;
</span><del>- case DoubleRepMachineIntUse:
- speculateDoubleRepMachineInt(edge);
</del><ins>+ case DoubleRepAnyIntUse:
+ speculateDoubleRepAnyInt(edge);
</ins><span class="cx"> break;
</span><span class="cx"> #endif
</span><span class="cx"> case BooleanUse:
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGSpeculativeJITh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -564,10 +564,10 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- bool isKnownInteger(Node* node) { return m_state.forNode(node).isType(SpecInt32); }
</del><ins>+ bool isKnownInteger(Node* node) { return m_state.forNode(node).isType(SpecInt32Only); }
</ins><span class="cx"> bool isKnownCell(Node* node) { return m_state.forNode(node).isType(SpecCell); }
</span><span class="cx">
</span><del>- bool isKnownNotInteger(Node* node) { return !(m_state.forNode(node).m_type & SpecInt32); }
</del><ins>+ bool isKnownNotInteger(Node* node) { return !(m_state.forNode(node).m_type & SpecInt32Only); }
</ins><span class="cx"> bool isKnownNotNumber(Node* node) { return !(m_state.forNode(node).m_type & SpecFullNumber); }
</span><span class="cx"> bool isKnownNotCell(Node* node) { return !(m_state.forNode(node).m_type & SpecCell); }
</span><span class="cx"> bool isKnownNotOther(Node* node) { return !(m_state.forNode(node).m_type & SpecOther); }
</span><span class="lines">@@ -2674,9 +2674,9 @@
</span><span class="cx">
</span><span class="cx"> void speculateInt32(Edge);
</span><span class="cx"> #if USE(JSVALUE64)
</span><del>- void convertMachineInt(Edge, GPRReg resultGPR);
- void speculateMachineInt(Edge);
- void speculateDoubleRepMachineInt(Edge);
</del><ins>+ void convertAnyInt(Edge, GPRReg resultGPR);
+ void speculateAnyInt(Edge);
+ void speculateDoubleRepAnyInt(Edge);
</ins><span class="cx"> #endif // USE(JSVALUE64)
</span><span class="cx"> void speculateNumber(Edge);
</span><span class="cx"> void speculateRealNumber(Edge);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGSpeculativeJIT32_64cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -943,9 +943,9 @@
</span><span class="cx"> {
</span><span class="cx"> AbstractValue& value = m_state.forNode(edge);
</span><span class="cx"> SpeculatedType type = value.m_type;
</span><del>- ASSERT(edge.useKind() != KnownInt32Use || !(value.m_type & ~SpecInt32));
</del><ins>+ ASSERT(edge.useKind() != KnownInt32Use || !(value.m_type & ~SpecInt32Only));
</ins><span class="cx">
</span><del>- m_interpreter.filter(value, SpecInt32);
</del><ins>+ m_interpreter.filter(value, SpecInt32Only);
</ins><span class="cx"> if (value.isClear()) {
</span><span class="cx"> terminateSpeculativeExecution(Uncountable, JSValueRegs(), 0);
</span><span class="cx"> returnFormat = DataFormatInt32;
</span><span class="lines">@@ -972,7 +972,7 @@
</span><span class="cx"> ASSERT_UNUSED(spillFormat, (spillFormat & DataFormatJS) || spillFormat == DataFormatInt32);
</span><span class="cx">
</span><span class="cx"> // If we know this was spilled as an integer we can fill without checking.
</span><del>- if (type & ~SpecInt32)
</del><ins>+ if (type & ~SpecInt32Only)
</ins><span class="cx"> speculationCheck(BadType, JSValueSource(JITCompiler::addressFor(virtualRegister)), edge, m_jit.branch32(MacroAssembler::NotEqual, JITCompiler::tagFor(virtualRegister), TrustedImm32(JSValue::Int32Tag)));
</span><span class="cx">
</span><span class="cx"> GPRReg gpr = allocate();
</span><span class="lines">@@ -990,7 +990,7 @@
</span><span class="cx"> GPRReg payloadGPR = info.payloadGPR();
</span><span class="cx"> m_gprs.lock(tagGPR);
</span><span class="cx"> m_gprs.lock(payloadGPR);
</span><del>- if (type & ~SpecInt32)
</del><ins>+ if (type & ~SpecInt32Only)
</ins><span class="cx"> speculationCheck(BadType, JSValueRegs(tagGPR, payloadGPR), edge, m_jit.branch32(MacroAssembler::NotEqual, tagGPR, TrustedImm32(JSValue::Int32Tag)));
</span><span class="cx"> m_gprs.unlock(tagGPR);
</span><span class="cx"> m_gprs.release(tagGPR);
</span><span class="lines">@@ -1899,8 +1899,8 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx"> case Int52RepUse:
</span><del>- case MachineIntUse:
- case DoubleRepMachineIntUse: {
</del><ins>+ case AnyIntUse:
+ case DoubleRepAnyIntUse: {
</ins><span class="cx"> RELEASE_ASSERT_NOT_REACHED();
</span><span class="cx"> break;
</span><span class="cx"> }
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGSpeculativeJIT64cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -901,9 +901,9 @@
</span><span class="cx"> {
</span><span class="cx"> AbstractValue& value = m_state.forNode(edge);
</span><span class="cx"> SpeculatedType type = value.m_type;
</span><del>- ASSERT(edge.useKind() != KnownInt32Use || !(value.m_type & ~SpecInt32));
</del><ins>+ ASSERT(edge.useKind() != KnownInt32Use || !(value.m_type & ~SpecInt32Only));
</ins><span class="cx">
</span><del>- m_interpreter.filter(value, SpecInt32);
</del><ins>+ m_interpreter.filter(value, SpecInt32Only);
</ins><span class="cx"> if (value.isClear()) {
</span><span class="cx"> terminateSpeculativeExecution(Uncountable, JSValueRegs(), 0);
</span><span class="cx"> returnFormat = DataFormatInt32;
</span><span class="lines">@@ -958,11 +958,11 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> case DataFormatJS: {
</span><del>- DFG_ASSERT(m_jit.graph(), m_currentNode, !(type & SpecInt52));
</del><ins>+ DFG_ASSERT(m_jit.graph(), m_currentNode, !(type & SpecInt52Only));
</ins><span class="cx"> // Check the value is an integer.
</span><span class="cx"> GPRReg gpr = info.gpr();
</span><span class="cx"> m_gprs.lock(gpr);
</span><del>- if (type & ~SpecInt32)
</del><ins>+ if (type & ~SpecInt32Only)
</ins><span class="cx"> speculationCheck(BadType, JSValueRegs(gpr), edge, m_jit.branch64(MacroAssembler::Below, gpr, GPRInfo::tagTypeNumberRegister));
</span><span class="cx"> info.fillJSValue(*m_stream, gpr, DataFormatJSInt32);
</span><span class="cx"> // If !strict we're done, return.
</span><span class="lines">@@ -1045,7 +1045,7 @@
</span><span class="cx"> ASSERT(desiredFormat == DataFormatInt52 || desiredFormat == DataFormatStrictInt52);
</span><span class="cx"> AbstractValue& value = m_state.forNode(edge);
</span><span class="cx">
</span><del>- m_interpreter.filter(value, SpecMachineInt);
</del><ins>+ m_interpreter.filter(value, SpecAnyInt);
</ins><span class="cx"> if (value.isClear()) {
</span><span class="cx"> terminateSpeculativeExecution(Uncountable, JSValueRegs(), 0);
</span><span class="cx"> return allocate();
</span><span class="lines">@@ -1060,9 +1060,9 @@
</span><span class="cx">
</span><span class="cx"> if (edge->hasConstant()) {
</span><span class="cx"> JSValue jsValue = edge->asJSValue();
</span><del>- ASSERT(jsValue.isMachineInt());
</del><ins>+ ASSERT(jsValue.isAnyInt());
</ins><span class="cx"> m_gprs.retain(gpr, virtualRegister, SpillOrderConstant);
</span><del>- int64_t value = jsValue.asMachineInt();
</del><ins>+ int64_t value = jsValue.asAnyInt();
</ins><span class="cx"> if (desiredFormat == DataFormatInt52)
</span><span class="cx"> value = value << JSValue::int52ShiftAmount;
</span><span class="cx"> m_jit.move(MacroAssembler::Imm64(value), gpr);
</span><span class="lines">@@ -1131,7 +1131,7 @@
</span><span class="cx">
</span><span class="cx"> FPRReg SpeculativeJIT::fillSpeculateDouble(Edge edge)
</span><span class="cx"> {
</span><del>- ASSERT(edge.useKind() == DoubleRepUse || edge.useKind() == DoubleRepRealUse || edge.useKind() == DoubleRepMachineIntUse);
</del><ins>+ ASSERT(edge.useKind() == DoubleRepUse || edge.useKind() == DoubleRepRealUse || edge.useKind() == DoubleRepAnyIntUse);
</ins><span class="cx"> ASSERT(edge->hasDoubleResult());
</span><span class="cx"> VirtualRegister virtualRegister = edge->virtualRegister();
</span><span class="cx"> GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
</span><span class="lines">@@ -1932,7 +1932,7 @@
</span><span class="cx"> GPRTemporary result(this);
</span><span class="cx"> GPRReg resultGPR = result.gpr();
</span><span class="cx">
</span><del>- if (node->child1()->prediction() & SpecInt32) {
</del><ins>+ if (node->child1()->prediction() & SpecInt32Only) {
</ins><span class="cx"> branch64(MacroAssembler::Equal, valueGPR, MacroAssembler::TrustedImm64(JSValue::encode(jsNumber(0))), notTaken);
</span><span class="cx"> branch64(MacroAssembler::AboveOrEqual, valueGPR, GPRInfo::tagTypeNumberRegister, taken);
</span><span class="cx"> }
</span><span class="lines">@@ -1987,7 +1987,7 @@
</span><span class="cx"> switch (node->child1().useKind()) {
</span><span class="cx"> case DoubleRepUse:
</span><span class="cx"> case DoubleRepRealUse:
</span><del>- case DoubleRepMachineIntUse: {
</del><ins>+ case DoubleRepAnyIntUse: {
</ins><span class="cx"> SpeculateDoubleOperand op(this, node->child1());
</span><span class="cx"> FPRTemporary scratch(this, op);
</span><span class="cx"> m_jit.moveDouble(op.fpr(), scratch.fpr());
</span><span class="lines">@@ -2222,17 +2222,17 @@
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- case MachineIntUse: {
</del><ins>+ case AnyIntUse: {
</ins><span class="cx"> GPRTemporary result(this);
</span><span class="cx"> GPRReg resultGPR = result.gpr();
</span><span class="cx">
</span><del>- convertMachineInt(node->child1(), resultGPR);
</del><ins>+ convertAnyInt(node->child1(), resultGPR);
</ins><span class="cx">
</span><span class="cx"> strictInt52Result(resultGPR, node);
</span><span class="cx"> break;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- case DoubleRepMachineIntUse: {
</del><ins>+ case DoubleRepAnyIntUse: {
</ins><span class="cx"> SpeculateDoubleOperand value(this, node->child1());
</span><span class="cx"> FPRReg valueFPR = value.fpr();
</span><span class="cx">
</span><span class="lines">@@ -2244,7 +2244,7 @@
</span><span class="cx"> callOperation(operationConvertDoubleToInt52, resultGPR, valueFPR);
</span><span class="cx">
</span><span class="cx"> DFG_TYPE_CHECK_WITH_EXIT_KIND(Int52Overflow,
</span><del>- JSValueRegs(), node->child1(), SpecInt52AsDouble,
</del><ins>+ JSValueRegs(), node->child1(), SpecAnyIntAsDouble,
</ins><span class="cx"> m_jit.branch64(
</span><span class="cx"> JITCompiler::Equal, resultGPR,
</span><span class="cx"> JITCompiler::TrustedImm64(JSValue::notInt52)));
</span><span class="lines">@@ -2827,7 +2827,7 @@
</span><span class="cx">
</span><span class="cx"> if (arrayMode.type() == Array::Int32) {
</span><span class="cx"> DFG_TYPE_CHECK(
</span><del>- JSValueRegs(valueReg), child3, SpecInt32,
</del><ins>+ JSValueRegs(valueReg), child3, SpecInt32Only,
</ins><span class="cx"> m_jit.branch64(
</span><span class="cx"> MacroAssembler::Below, valueReg, GPRInfo::tagTypeNumberRegister));
</span><span class="cx"> }
</span><span class="lines">@@ -3219,7 +3219,7 @@
</span><span class="cx">
</span><span class="cx"> if (node->arrayMode().type() == Array::Int32) {
</span><span class="cx"> DFG_TYPE_CHECK(
</span><del>- JSValueRegs(valueGPR), node->child2(), SpecInt32,
</del><ins>+ JSValueRegs(valueGPR), node->child2(), SpecInt32Only,
</ins><span class="cx"> m_jit.branch64(
</span><span class="cx"> MacroAssembler::Below, valueGPR, GPRInfo::tagTypeNumberRegister));
</span><span class="cx"> }
</span><span class="lines">@@ -3599,7 +3599,7 @@
</span><span class="cx"> GPRReg opGPR = operand.gpr();
</span><span class="cx"> if (hasInt32(node->indexingType())) {
</span><span class="cx"> DFG_TYPE_CHECK(
</span><del>- JSValueRegs(opGPR), use, SpecInt32,
</del><ins>+ JSValueRegs(opGPR), use, SpecInt32Only,
</ins><span class="cx"> m_jit.branch64(
</span><span class="cx"> MacroAssembler::Below, opGPR, GPRInfo::tagTypeNumberRegister));
</span><span class="cx"> }
</span><span class="lines">@@ -3665,7 +3665,7 @@
</span><span class="cx"> GPRReg opGPR = operand.gpr();
</span><span class="cx"> if (hasInt32(node->indexingType())) {
</span><span class="cx"> DFG_TYPE_CHECK(
</span><del>- JSValueRegs(opGPR), use, SpecInt32,
</del><ins>+ JSValueRegs(opGPR), use, SpecInt32Only,
</ins><span class="cx"> m_jit.branch64(
</span><span class="cx"> MacroAssembler::Below, opGPR, GPRInfo::tagTypeNumberRegister));
</span><span class="cx"> }
</span><span class="lines">@@ -4998,7 +4998,7 @@
</span><span class="cx"> m_jit.move(valueGPR, scratch2GPR);
</span><span class="cx"> m_jit.and64(TrustedImm32(~1), scratch2GPR);
</span><span class="cx"> jumpToEnd.append(m_jit.branch64(MacroAssembler::Equal, scratch2GPR, MacroAssembler::TrustedImm64(ValueFalse)));
</span><del>- } else if (cachedTypeLocation->m_lastSeenType == TypeMachineInt)
</del><ins>+ } else if (cachedTypeLocation->m_lastSeenType == TypeAnyInt)
</ins><span class="cx"> jumpToEnd.append(m_jit.branch64(MacroAssembler::AboveOrEqual, valueGPR, GPRInfo::tagTypeNumberRegister));
</span><span class="cx"> else if (cachedTypeLocation->m_lastSeenType == TypeNumber)
</span><span class="cx"> jumpToEnd.append(m_jit.branchTest64(MacroAssembler::NonZero, valueGPR, GPRInfo::tagTypeNumberRegister));
</span><span class="lines">@@ -5207,7 +5207,7 @@
</span><span class="cx"> m_jit.or32(TrustedImm32(ValueFalse), gpr);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void SpeculativeJIT::convertMachineInt(Edge valueEdge, GPRReg resultGPR)
</del><ins>+void SpeculativeJIT::convertAnyInt(Edge valueEdge, GPRReg resultGPR)
</ins><span class="cx"> {
</span><span class="cx"> JSValueOperand value(this, valueEdge, ManualOperandSpeculation);
</span><span class="cx"> GPRReg valueGPR = value.gpr();
</span><span class="lines">@@ -5224,25 +5224,25 @@
</span><span class="cx"> silentFillAllRegisters(resultGPR);
</span><span class="cx">
</span><span class="cx"> DFG_TYPE_CHECK(
</span><del>- JSValueRegs(valueGPR), valueEdge, SpecInt32 | SpecInt52AsDouble,
</del><ins>+ JSValueRegs(valueGPR), valueEdge, SpecInt32Only | SpecAnyIntAsDouble,
</ins><span class="cx"> m_jit.branch64(
</span><span class="cx"> JITCompiler::Equal, resultGPR,
</span><span class="cx"> JITCompiler::TrustedImm64(JSValue::notInt52)));
</span><span class="cx"> done.link(&m_jit);
</span><span class="cx"> }
</span><span class="cx">
</span><del>-void SpeculativeJIT::speculateMachineInt(Edge edge)
</del><ins>+void SpeculativeJIT::speculateAnyInt(Edge edge)
</ins><span class="cx"> {
</span><del>- if (!needsTypeCheck(edge, SpecInt32 | SpecInt52AsDouble))
</del><ins>+ if (!needsTypeCheck(edge, SpecInt32Only | SpecAnyIntAsDouble))
</ins><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> GPRTemporary temp(this);
</span><del>- convertMachineInt(edge, temp.gpr());
</del><ins>+ convertAnyInt(edge, temp.gpr());
</ins><span class="cx"> }
</span><span class="cx">
</span><del>-void SpeculativeJIT::speculateDoubleRepMachineInt(Edge edge)
</del><ins>+void SpeculativeJIT::speculateDoubleRepAnyInt(Edge edge)
</ins><span class="cx"> {
</span><del>- if (!needsTypeCheck(edge, SpecInt52AsDouble))
</del><ins>+ if (!needsTypeCheck(edge, SpecAnyIntAsDouble))
</ins><span class="cx"> return;
</span><span class="cx">
</span><span class="cx"> SpeculateDoubleOperand value(this, edge);
</span><span class="lines">@@ -5256,7 +5256,7 @@
</span><span class="cx"> callOperation(operationConvertDoubleToInt52, resultGPR, valueFPR);
</span><span class="cx">
</span><span class="cx"> DFG_TYPE_CHECK(
</span><del>- JSValueRegs(), edge, SpecInt52AsDouble,
</del><ins>+ JSValueRegs(), edge, SpecAnyIntAsDouble,
</ins><span class="cx"> m_jit.branch64(
</span><span class="cx"> JITCompiler::Equal, resultGPR,
</span><span class="cx"> JITCompiler::TrustedImm64(JSValue::notInt52)));
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGUseKindcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGUseKind.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGUseKind.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGUseKind.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -49,8 +49,8 @@
</span><span class="cx"> case Int52RepUse:
</span><span class="cx"> out.print("Int52Rep");
</span><span class="cx"> return;
</span><del>- case MachineIntUse:
- out.print("MachineInt");
</del><ins>+ case AnyIntUse:
+ out.print("AnyInt");
</ins><span class="cx"> return;
</span><span class="cx"> case NumberUse:
</span><span class="cx"> out.print("Number");
</span><span class="lines">@@ -64,8 +64,8 @@
</span><span class="cx"> case DoubleRepRealUse:
</span><span class="cx"> out.print("DoubleRepReal");
</span><span class="cx"> return;
</span><del>- case DoubleRepMachineIntUse:
- out.print("DoubleRepMachineInt");
</del><ins>+ case DoubleRepAnyIntUse:
+ out.print("DoubleRepAnyInt");
</ins><span class="cx"> return;
</span><span class="cx"> case BooleanUse:
</span><span class="cx"> out.print("Boolean");
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGUseKindh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGUseKind.h (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGUseKind.h 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGUseKind.h 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -44,7 +44,7 @@
</span><span class="cx"> UntypedUse, // UntypedUse must come first (value 0).
</span><span class="cx"> Int32Use,
</span><span class="cx"> KnownInt32Use,
</span><del>- MachineIntUse,
</del><ins>+ AnyIntUse,
</ins><span class="cx"> NumberUse,
</span><span class="cx"> RealNumberUse,
</span><span class="cx"> BooleanUse,
</span><span class="lines">@@ -74,7 +74,7 @@
</span><span class="cx"> // in an FP register.
</span><span class="cx"> DoubleRepUse,
</span><span class="cx"> DoubleRepRealUse,
</span><del>- DoubleRepMachineIntUse,
</del><ins>+ DoubleRepAnyIntUse,
</ins><span class="cx">
</span><span class="cx"> // 3. The Int52 representation for an unboxed integer value that must be stored
</span><span class="cx"> // in a GP register.
</span><span class="lines">@@ -90,11 +90,11 @@
</span><span class="cx"> return SpecFullTop;
</span><span class="cx"> case Int32Use:
</span><span class="cx"> case KnownInt32Use:
</span><del>- return SpecInt32;
</del><ins>+ return SpecInt32Only;
</ins><span class="cx"> case Int52RepUse:
</span><del>- return SpecMachineInt;
- case MachineIntUse:
- return SpecInt32 | SpecInt52AsDouble;
</del><ins>+ return SpecAnyInt;
+ case AnyIntUse:
+ return SpecInt32Only | SpecAnyIntAsDouble;
</ins><span class="cx"> case NumberUse:
</span><span class="cx"> return SpecBytecodeNumber;
</span><span class="cx"> case RealNumberUse:
</span><span class="lines">@@ -103,8 +103,8 @@
</span><span class="cx"> return SpecFullDouble;
</span><span class="cx"> case DoubleRepRealUse:
</span><span class="cx"> return SpecDoubleReal;
</span><del>- case DoubleRepMachineIntUse:
- return SpecInt52AsDouble;
</del><ins>+ case DoubleRepAnyIntUse:
+ return SpecAnyIntAsDouble;
</ins><span class="cx"> case BooleanUse:
</span><span class="cx"> case KnownBooleanUse:
</span><span class="cx"> return SpecBoolean;
</span><span class="lines">@@ -184,8 +184,8 @@
</span><span class="cx"> case Int52RepUse:
</span><span class="cx"> case DoubleRepUse:
</span><span class="cx"> case DoubleRepRealUse:
</span><del>- case MachineIntUse:
- case DoubleRepMachineIntUse:
</del><ins>+ case AnyIntUse:
+ case DoubleRepAnyIntUse:
</ins><span class="cx"> return true;
</span><span class="cx"> default:
</span><span class="cx"> return false;
</span><span class="lines">@@ -197,7 +197,7 @@
</span><span class="cx"> switch (kind) {
</span><span class="cx"> case DoubleRepUse:
</span><span class="cx"> case DoubleRepRealUse:
</span><del>- case DoubleRepMachineIntUse:
</del><ins>+ case DoubleRepAnyIntUse:
</ins><span class="cx"> return true;
</span><span class="cx"> default:
</span><span class="cx"> return false;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGValidatecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGValidate.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGValidate.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGValidate.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -694,7 +694,7 @@
</span><span class="cx"> if (m_graph.m_planStage < PlanStage::AfterFixup)
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- VALIDATE((node, edge), edge.useKind() == DoubleRepUse || edge.useKind() == DoubleRepRealUse || edge.useKind() == DoubleRepMachineIntUse);
</del><ins>+ VALIDATE((node, edge), edge.useKind() == DoubleRepUse || edge.useKind() == DoubleRepRealUse || edge.useKind() == DoubleRepAnyIntUse);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void checkOperand(
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoredfgDFGVariableAccessDatacpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/dfg/DFGVariableAccessData.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/dfg/DFGVariableAccessData.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/dfg/DFGVariableAccessData.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -156,8 +156,8 @@
</span><span class="cx"> SpeculatedType type = m_prediction;
</span><span class="cx"> if (type & ~SpecBytecodeNumber)
</span><span class="cx"> type |= SpecDoublePureNaN;
</span><del>- if (type & SpecMachineInt)
- type |= SpecInt52AsDouble;
</del><ins>+ if (type & SpecAnyInt)
+ type |= SpecAnyIntAsDouble;
</ins><span class="cx"> return checkAndSet(m_prediction, type);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -180,8 +180,8 @@
</span><span class="cx"> return false;
</span><span class="cx">
</span><span class="cx"> // The argument-aware prediction -- which merges all of an (inlined or machine)
</span><del>- // argument's variable access datas' predictions -- must possibly be MachineInt.
- return !(argumentAwarePrediction() & ~SpecMachineInt);
</del><ins>+ // argument's variable access datas' predictions -- must possibly be AnyInt.
+ return !(argumentAwarePrediction() & ~SpecAnyInt);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> FlushFormat VariableAccessData::flushFormat()
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLCapabilitiescpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLCapabilities.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLCapabilities.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/ftl/FTLCapabilities.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -500,8 +500,8 @@
</span><span class="cx"> case MiscUse:
</span><span class="cx"> case StringIdentUse:
</span><span class="cx"> case NotStringVarUse:
</span><del>- case MachineIntUse:
- case DoubleRepMachineIntUse:
</del><ins>+ case AnyIntUse:
+ case DoubleRepAnyIntUse:
</ins><span class="cx"> // These are OK.
</span><span class="cx"> break;
</span><span class="cx"> default:
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreftlFTLLowerDFGToB3cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -1082,7 +1082,7 @@
</span><span class="cx">
</span><span class="cx"> void compileInt52Constant()
</span><span class="cx"> {
</span><del>- int64_t value = m_node->asMachineInt();
</del><ins>+ int64_t value = m_node->asAnyInt();
</ins><span class="cx">
</span><span class="cx"> setInt52(m_out.constInt64(value << JSValue::int52ShiftAmount));
</span><span class="cx"> setStrictInt52(m_out.constInt64(value));
</span><span class="lines">@@ -1261,13 +1261,13 @@
</span><span class="cx"> setStrictInt52(m_out.signExt32To64(lowInt32(m_node->child1())));
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- case MachineIntUse:
</del><ins>+ case AnyIntUse:
</ins><span class="cx"> setStrictInt52(
</span><span class="cx"> jsValueToStrictInt52(
</span><span class="cx"> m_node->child1(), lowJSValue(m_node->child1(), ManualOperandSpeculation)));
</span><span class="cx"> return;
</span><span class="cx">
</span><del>- case DoubleRepMachineIntUse:
</del><ins>+ case DoubleRepAnyIntUse:
</ins><span class="cx"> setStrictInt52(
</span><span class="cx"> doubleToStrictInt52(
</span><span class="cx"> m_node->child1(), lowDouble(m_node->child1())));
</span><span class="lines">@@ -1538,8 +1538,8 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> case Int52RepUse: {
</span><del>- if (!abstractValue(m_node->child1()).couldBeType(SpecInt52)
- && !abstractValue(m_node->child2()).couldBeType(SpecInt52)) {
</del><ins>+ if (!abstractValue(m_node->child1()).couldBeType(SpecInt52Only)
+ && !abstractValue(m_node->child2()).couldBeType(SpecInt52Only)) {
</ins><span class="cx"> Int52Kind kind;
</span><span class="cx"> LValue left = lowWhicheverInt52(m_node->child1(), kind);
</span><span class="cx"> LValue right = lowInt52(m_node->child2(), kind);
</span><span class="lines">@@ -2085,7 +2085,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> case Int52RepUse: {
</span><del>- if (!abstractValue(m_node->child1()).couldBeType(SpecInt52)) {
</del><ins>+ if (!abstractValue(m_node->child1()).couldBeType(SpecInt52Only)) {
</ins><span class="cx"> Int52Kind kind;
</span><span class="cx"> LValue value = lowWhicheverInt52(m_node->child1(), kind);
</span><span class="cx"> LValue result = m_out.neg(value);
</span><span class="lines">@@ -2858,7 +2858,7 @@
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (m_node->shouldSpeculateMachineInt()) {
</del><ins>+ if (m_node->shouldSpeculateAnyInt()) {
</ins><span class="cx"> setStrictInt52(m_out.zeroExt(result, m_out.int64));
</span><span class="cx"> return;
</span><span class="cx"> }
</span><span class="lines">@@ -2999,7 +2999,7 @@
</span><span class="cx"> LValue value = lowJSValue(child3, ManualOperandSpeculation);
</span><span class="cx">
</span><span class="cx"> if (m_node->arrayMode().type() == Array::Int32)
</span><del>- FTL_TYPE_CHECK(jsValueValue(value), child3, SpecInt32, isNotInt32(value));
</del><ins>+ FTL_TYPE_CHECK(jsValueValue(value), child3, SpecInt32Only, isNotInt32(value));
</ins><span class="cx">
</span><span class="cx"> TypedPointer elementPointer = m_out.baseIndex(
</span><span class="cx"> m_node->arrayMode().type() == Array::Int32 ?
</span><span class="lines">@@ -3249,7 +3249,7 @@
</span><span class="cx"> value = lowJSValue(m_node->child2(), ManualOperandSpeculation);
</span><span class="cx"> if (m_node->arrayMode().type() == Array::Int32) {
</span><span class="cx"> FTL_TYPE_CHECK(
</span><del>- jsValueValue(value), m_node->child2(), SpecInt32, isNotInt32(value));
</del><ins>+ jsValueValue(value), m_node->child2(), SpecInt32Only, isNotInt32(value));
</ins><span class="cx"> }
</span><span class="cx"> storeType = Output::Store64;
</span><span class="cx"> } else {
</span><span class="lines">@@ -9313,13 +9313,13 @@
</span><span class="cx"> if (isValid(value)) {
</span><span class="cx"> LValue boxedResult = value.value();
</span><span class="cx"> FTL_TYPE_CHECK(
</span><del>- jsValueValue(boxedResult), edge, SpecInt32, isNotInt32(boxedResult));
</del><ins>+ jsValueValue(boxedResult), edge, SpecInt32Only, isNotInt32(boxedResult));
</ins><span class="cx"> LValue result = unboxInt32(boxedResult);
</span><span class="cx"> setInt32(edge.node(), result);
</span><span class="cx"> return result;
</span><span class="cx"> }
</span><span class="cx">
</span><del>- DFG_ASSERT(m_graph, m_node, !(provenType(edge) & SpecInt32));
</del><ins>+ DFG_ASSERT(m_graph, m_node, !(provenType(edge) & SpecInt32Only));
</ins><span class="cx"> terminate(Uncountable);
</span><span class="cx"> return m_out.int32Zero;
</span><span class="cx"> }
</span><span class="lines">@@ -9568,7 +9568,7 @@
</span><span class="cx"> {
</span><span class="cx"> LValue result = m_out.castToInt32(value);
</span><span class="cx"> FTL_TYPE_CHECK(
</span><del>- noValue(), edge, SpecInt32,
</del><ins>+ noValue(), edge, SpecInt32Only,
</ins><span class="cx"> m_out.notEqual(m_out.signExt32To64(result), value));
</span><span class="cx"> setInt32(edge.node(), result);
</span><span class="cx"> return result;
</span><span class="lines">@@ -9618,13 +9618,13 @@
</span><span class="cx">
</span><span class="cx"> LValue isInt32(LValue jsValue, SpeculatedType type = SpecFullTop)
</span><span class="cx"> {
</span><del>- if (LValue proven = isProvenValue(type, SpecInt32))
</del><ins>+ if (LValue proven = isProvenValue(type, SpecInt32Only))
</ins><span class="cx"> return proven;
</span><span class="cx"> return m_out.aboveOrEqual(jsValue, m_tagTypeNumber);
</span><span class="cx"> }
</span><span class="cx"> LValue isNotInt32(LValue jsValue, SpeculatedType type = SpecFullTop)
</span><span class="cx"> {
</span><del>- if (LValue proven = isProvenValue(type, ~SpecInt32))
</del><ins>+ if (LValue proven = isProvenValue(type, ~SpecInt32Only))
</ins><span class="cx"> return proven;
</span><span class="cx"> return m_out.below(jsValue, m_tagTypeNumber);
</span><span class="cx"> }
</span><span class="lines">@@ -9666,9 +9666,9 @@
</span><span class="cx"> LBasicBlock continuation = m_out.newBlock();
</span><span class="cx">
</span><span class="cx"> LValue isNotInt32;
</span><del>- if (!m_interpreter.needsTypeCheck(edge, SpecInt32))
</del><ins>+ if (!m_interpreter.needsTypeCheck(edge, SpecInt32Only))
</ins><span class="cx"> isNotInt32 = m_out.booleanFalse;
</span><del>- else if (!m_interpreter.needsTypeCheck(edge, ~SpecInt32))
</del><ins>+ else if (!m_interpreter.needsTypeCheck(edge, ~SpecInt32Only))
</ins><span class="cx"> isNotInt32 = m_out.booleanTrue;
</span><span class="cx"> else
</span><span class="cx"> isNotInt32 = this->isNotInt32(boxedValue);
</span><span class="lines">@@ -9685,7 +9685,7 @@
</span><span class="cx"> LValue possibleResult = m_out.call(
</span><span class="cx"> m_out.int64, m_out.operation(operationConvertBoxedDoubleToInt52), boxedValue);
</span><span class="cx"> FTL_TYPE_CHECK(
</span><del>- jsValueValue(boxedValue), edge, SpecInt32 | SpecInt52AsDouble,
</del><ins>+ jsValueValue(boxedValue), edge, SpecInt32Only | SpecAnyIntAsDouble,
</ins><span class="cx"> m_out.equal(possibleResult, m_out.constInt64(JSValue::notInt52)));
</span><span class="cx">
</span><span class="cx"> ValueFromBlock doubleToInt52 = m_out.anchor(possibleResult);
</span><span class="lines">@@ -9701,7 +9701,7 @@
</span><span class="cx"> LValue possibleResult = m_out.call(
</span><span class="cx"> m_out.int64, m_out.operation(operationConvertDoubleToInt52), value);
</span><span class="cx"> FTL_TYPE_CHECK_WITH_EXIT_KIND(Int52Overflow,
</span><del>- doubleValue(value), edge, SpecInt52AsDouble,
</del><ins>+ doubleValue(value), edge, SpecAnyIntAsDouble,
</ins><span class="cx"> m_out.equal(possibleResult, m_out.constInt64(JSValue::notInt52)));
</span><span class="cx">
</span><span class="cx"> return possibleResult;
</span><span class="lines">@@ -9848,8 +9848,8 @@
</span><span class="cx"> case KnownCellUse:
</span><span class="cx"> ASSERT(!m_interpreter.needsTypeCheck(edge));
</span><span class="cx"> break;
</span><del>- case MachineIntUse:
- speculateMachineInt(edge);
</del><ins>+ case AnyIntUse:
+ speculateAnyInt(edge);
</ins><span class="cx"> break;
</span><span class="cx"> case ObjectUse:
</span><span class="cx"> speculateObject(edge);
</span><span class="lines">@@ -9893,8 +9893,8 @@
</span><span class="cx"> case DoubleRepRealUse:
</span><span class="cx"> speculateDoubleRepReal(edge);
</span><span class="cx"> break;
</span><del>- case DoubleRepMachineIntUse:
- speculateDoubleRepMachineInt(edge);
</del><ins>+ case DoubleRepAnyIntUse:
+ speculateDoubleRepAnyInt(edge);
</ins><span class="cx"> break;
</span><span class="cx"> case BooleanUse:
</span><span class="cx"> speculateBoolean(edge);
</span><span class="lines">@@ -9947,7 +9947,7 @@
</span><span class="cx"> m_out.appendTo(continuation, lastNext);
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void speculateMachineInt(Edge edge)
</del><ins>+ void speculateAnyInt(Edge edge)
</ins><span class="cx"> {
</span><span class="cx"> if (!m_interpreter.needsTypeCheck(edge))
</span><span class="cx"> return;
</span><span class="lines">@@ -10345,7 +10345,7 @@
</span><span class="cx"> m_out.doubleNotEqualOrUnordered(value, value));
</span><span class="cx"> }
</span><span class="cx">
</span><del>- void speculateDoubleRepMachineInt(Edge edge)
</del><ins>+ void speculateDoubleRepAnyInt(Edge edge)
</ins><span class="cx"> {
</span><span class="cx"> if (!m_interpreter.needsTypeCheck(edge))
</span><span class="cx"> return;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITOpcodescpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -1297,7 +1297,7 @@
</span><span class="cx"> move(regT0, regT1);
</span><span class="cx"> and64(TrustedImm32(~1), regT1);
</span><span class="cx"> jumpToEnd.append(branch64(Equal, regT1, TrustedImm64(ValueFalse)));
</span><del>- } else if (cachedTypeLocation->m_lastSeenType == TypeMachineInt)
</del><ins>+ } else if (cachedTypeLocation->m_lastSeenType == TypeAnyInt)
</ins><span class="cx"> jumpToEnd.append(emitJumpIfInt(regT0));
</span><span class="cx"> else if (cachedTypeLocation->m_lastSeenType == TypeNumber)
</span><span class="cx"> jumpToEnd.append(emitJumpIfNumber(regT0));
</span></span></pre></div>
<a id="trunkSourceJavaScriptCorejitJITOpcodes32_64cpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -1298,7 +1298,7 @@
</span><span class="cx"> jumpToEnd.append(branch32(Equal, regT3, TrustedImm32(JSValue::NullTag)));
</span><span class="cx"> else if (cachedTypeLocation->m_lastSeenType == TypeBoolean)
</span><span class="cx"> jumpToEnd.append(branch32(Equal, regT3, TrustedImm32(JSValue::BooleanTag)));
</span><del>- else if (cachedTypeLocation->m_lastSeenType == TypeMachineInt)
</del><ins>+ else if (cachedTypeLocation->m_lastSeenType == TypeAnyInt)
</ins><span class="cx"> jumpToEnd.append(branch32(Equal, regT3, TrustedImm32(JSValue::Int32Tag)));
</span><span class="cx"> else if (cachedTypeLocation->m_lastSeenType == TypeNumber) {
</span><span class="cx"> jumpToEnd.append(branch32(Below, regT3, TrustedImm32(JSValue::LowestTag)));
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreruntimeJSCJSValueh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/runtime/JSCJSValue.h (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/runtime/JSCJSValue.h 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/runtime/JSCJSValue.h 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -214,7 +214,7 @@
</span><span class="cx">
</span><span class="cx"> int32_t asInt32() const;
</span><span class="cx"> uint32_t asUInt32() const;
</span><del>- int64_t asMachineInt() const;
</del><ins>+ int64_t asAnyInt() const;
</ins><span class="cx"> double asDouble() const;
</span><span class="cx"> bool asBoolean() const;
</span><span class="cx"> double asNumber() const;
</span><span class="lines">@@ -232,7 +232,7 @@
</span><span class="cx"> bool isNull() const;
</span><span class="cx"> bool isUndefinedOrNull() const;
</span><span class="cx"> bool isBoolean() const;
</span><del>- bool isMachineInt() const;
</del><ins>+ bool isAnyInt() const;
</ins><span class="cx"> bool isNumber() const;
</span><span class="cx"> bool isString() const;
</span><span class="cx"> bool isSymbol() const;
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreruntimeJSCJSValueInlinesh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/runtime/JSCJSValueInlines.h (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/runtime/JSCJSValueInlines.h 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/runtime/JSCJSValueInlines.h 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -530,7 +530,7 @@
</span><span class="cx"> return tryConvertToInt52(number) != JSValue::notInt52;
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline bool JSValue::isMachineInt() const
</del><ins>+inline bool JSValue::isAnyInt() const
</ins><span class="cx"> {
</span><span class="cx"> if (isInt32())
</span><span class="cx"> return true;
</span><span class="lines">@@ -539,9 +539,9 @@
</span><span class="cx"> return isInt52(asDouble());
</span><span class="cx"> }
</span><span class="cx">
</span><del>-inline int64_t JSValue::asMachineInt() const
</del><ins>+inline int64_t JSValue::asAnyInt() const
</ins><span class="cx"> {
</span><del>- ASSERT(isMachineInt());
</del><ins>+ ASSERT(isAnyInt());
</ins><span class="cx"> if (isInt32())
</span><span class="cx"> return asInt32();
</span><span class="cx"> return static_cast<int64_t>(asDouble());
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreruntimeRuntimeTypecpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/runtime/RuntimeType.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/runtime/RuntimeType.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/runtime/RuntimeType.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -42,8 +42,8 @@
</span><span class="cx"> return TypeUndefined;
</span><span class="cx"> if (value.isNull())
</span><span class="cx"> return TypeNull;
</span><del>- if (value.isMachineInt())
- return TypeMachineInt;
</del><ins>+ if (value.isAnyInt())
+ return TypeAnyInt;
</ins><span class="cx"> if (value.isNumber())
</span><span class="cx"> return TypeNumber;
</span><span class="cx"> if (value.isString())
</span><span class="lines">@@ -66,7 +66,7 @@
</span><span class="cx"> return ASCIILiteral("Undefined");
</span><span class="cx"> if (type == TypeNull)
</span><span class="cx"> return ASCIILiteral("Null");
</span><del>- if (type == TypeMachineInt)
</del><ins>+ if (type == TypeAnyInt)
</ins><span class="cx"> return ASCIILiteral("Integer");
</span><span class="cx"> if (type == TypeNumber)
</span><span class="cx"> return ASCIILiteral("Number");
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreruntimeRuntimeTypeh"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/runtime/RuntimeType.h (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/runtime/RuntimeType.h 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/runtime/RuntimeType.h 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -37,7 +37,7 @@
</span><span class="cx"> TypeUndefined = 0x2,
</span><span class="cx"> TypeNull = 0x4,
</span><span class="cx"> TypeBoolean = 0x8,
</span><del>- TypeMachineInt = 0x10,
</del><ins>+ TypeAnyInt = 0x10,
</ins><span class="cx"> TypeNumber = 0x20,
</span><span class="cx"> TypeString = 0x40,
</span><span class="cx"> TypeObject = 0x80,
</span><span class="lines">@@ -46,7 +46,7 @@
</span><span class="cx">
</span><span class="cx"> typedef uint16_t RuntimeTypeMask;
</span><span class="cx">
</span><del>-static const RuntimeTypeMask RuntimeTypeMaskAllTypes = TypeFunction | TypeUndefined | TypeNull | TypeBoolean | TypeMachineInt | TypeNumber | TypeString | TypeObject | TypeSymbol;
</del><ins>+static const RuntimeTypeMask RuntimeTypeMaskAllTypes = TypeFunction | TypeUndefined | TypeNull | TypeBoolean | TypeAnyInt | TypeNumber | TypeString | TypeObject | TypeSymbol;
</ins><span class="cx">
</span><span class="cx"> class JSValue;
</span><span class="cx"> RuntimeType runtimeTypeForValue(JSValue);
</span></span></pre></div>
<a id="trunkSourceJavaScriptCoreruntimeTypeSetcpp"></a>
<div class="modfile"><h4>Modified: trunk/Source/JavaScriptCore/runtime/TypeSet.cpp (200033 => 200034)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/Source/JavaScriptCore/runtime/TypeSet.cpp 2016-04-25 17:33:08 UTC (rev 200033)
+++ trunk/Source/JavaScriptCore/runtime/TypeSet.cpp 2016-04-25 17:48:46 UTC (rev 200034)
</span><span class="lines">@@ -100,8 +100,8 @@
</span><span class="cx"> seen.appendLiteral("Null ");
</span><span class="cx"> if (m_seenTypes & TypeBoolean)
</span><span class="cx"> seen.appendLiteral("Boolean ");
</span><del>- if (m_seenTypes & TypeMachineInt)
- seen.appendLiteral("MachineInt ");
</del><ins>+ if (m_seenTypes & TypeAnyInt)
+ seen.appendLiteral("AnyInt ");
</ins><span class="cx"> if (m_seenTypes & TypeNumber)
</span><span class="cx"> seen.appendLiteral("Number ");
</span><span class="cx"> if (m_seenTypes & TypeString)
</span><span class="lines">@@ -179,9 +179,9 @@
</span><span class="cx"> return ASCIILiteral("Null");
</span><span class="cx"> if (doesTypeConformTo(TypeBoolean))
</span><span class="cx"> return ASCIILiteral("Boolean");
</span><del>- if (doesTypeConformTo(TypeMachineInt))
</del><ins>+ if (doesTypeConformTo(TypeAnyInt))
</ins><span class="cx"> return ASCIILiteral("Integer");
</span><del>- if (doesTypeConformTo(TypeNumber | TypeMachineInt))
</del><ins>+ if (doesTypeConformTo(TypeNumber | TypeAnyInt))
</ins><span class="cx"> return ASCIILiteral("Number");
</span><span class="cx"> if (doesTypeConformTo(TypeString))
</span><span class="cx"> return ASCIILiteral("String");
</span><span class="lines">@@ -195,9 +195,9 @@
</span><span class="cx"> return ASCIILiteral("Function?");
</span><span class="cx"> if (doesTypeConformTo(TypeBoolean | TypeNull | TypeUndefined))
</span><span class="cx"> return ASCIILiteral("Boolean?");
</span><del>- if (doesTypeConformTo(TypeMachineInt | TypeNull | TypeUndefined))
</del><ins>+ if (doesTypeConformTo(TypeAnyInt | TypeNull | TypeUndefined))
</ins><span class="cx"> return ASCIILiteral("Integer?");
</span><del>- if (doesTypeConformTo(TypeNumber | TypeMachineInt | TypeNull | TypeUndefined))
</del><ins>+ if (doesTypeConformTo(TypeNumber | TypeAnyInt | TypeNull | TypeUndefined))
</ins><span class="cx"> return ASCIILiteral("Number?");
</span><span class="cx"> if (doesTypeConformTo(TypeString | TypeNull | TypeUndefined))
</span><span class="cx"> return ASCIILiteral("String?");
</span><span class="lines">@@ -234,7 +234,7 @@
</span><span class="cx"> .setIsUndefined((m_seenTypes & TypeUndefined) != TypeNothing)
</span><span class="cx"> .setIsNull((m_seenTypes & TypeNull) != TypeNothing)
</span><span class="cx"> .setIsBoolean((m_seenTypes & TypeBoolean) != TypeNothing)
</span><del>- .setIsInteger((m_seenTypes & TypeMachineInt) != TypeNothing)
</del><ins>+ .setIsInteger((m_seenTypes & TypeAnyInt) != TypeNothing)
</ins><span class="cx"> .setIsNumber((m_seenTypes & TypeNumber) != TypeNothing)
</span><span class="cx"> .setIsString((m_seenTypes & TypeString) != TypeNothing)
</span><span class="cx"> .setIsObject((m_seenTypes & TypeObject) != TypeNothing)
</span><span class="lines">@@ -277,7 +277,7 @@
</span><span class="cx"> hasAnItem = true;
</span><span class="cx"> json.appendLiteral("\"Boolean\"");
</span><span class="cx"> }
</span><del>- if (m_seenTypes & TypeMachineInt) {
</del><ins>+ if (m_seenTypes & TypeAnyInt) {
</ins><span class="cx"> if (hasAnItem)
</span><span class="cx"> json.append(',');
</span><span class="cx"> hasAnItem = true;
</span></span></pre>
</div>
</div>
</body>
</html>