Renaming SpecInt32, SpecInt52, MachineInt to SpecInt32Only, SpecInt52Only, AnyInt.
authormark.lam@apple.com <mark.lam@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 25 Apr 2016 17:48:46 +0000 (17:48 +0000)
committermark.lam@apple.com <mark.lam@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 25 Apr 2016 17:48:46 +0000 (17:48 +0000)
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):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@200034 268f45cc-cd09-0410-ab3c-d52691b4dbfc

37 files changed:
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/bindings/ScriptValue.cpp
Source/JavaScriptCore/bytecode/SpeculatedType.cpp
Source/JavaScriptCore/bytecode/SpeculatedType.h
Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h
Source/JavaScriptCore/dfg/DFGAbstractValue.cpp
Source/JavaScriptCore/dfg/DFGAbstractValue.h
Source/JavaScriptCore/dfg/DFGArgumentsUtilities.cpp
Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp
Source/JavaScriptCore/dfg/DFGFixupPhase.cpp
Source/JavaScriptCore/dfg/DFGGraph.h
Source/JavaScriptCore/dfg/DFGInPlaceAbstractState.cpp
Source/JavaScriptCore/dfg/DFGJITCompiler.cpp
Source/JavaScriptCore/dfg/DFGNode.cpp
Source/JavaScriptCore/dfg/DFGNode.h
Source/JavaScriptCore/dfg/DFGOSREntry.cpp
Source/JavaScriptCore/dfg/DFGOSREntry.h
Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp
Source/JavaScriptCore/dfg/DFGSSALoweringPhase.cpp
Source/JavaScriptCore/dfg/DFGSafeToExecute.h
Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp
Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h
Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp
Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp
Source/JavaScriptCore/dfg/DFGUseKind.cpp
Source/JavaScriptCore/dfg/DFGUseKind.h
Source/JavaScriptCore/dfg/DFGValidate.cpp
Source/JavaScriptCore/dfg/DFGVariableAccessData.cpp
Source/JavaScriptCore/ftl/FTLCapabilities.cpp
Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp
Source/JavaScriptCore/jit/JITOpcodes.cpp
Source/JavaScriptCore/jit/JITOpcodes32_64.cpp
Source/JavaScriptCore/runtime/JSCJSValue.h
Source/JavaScriptCore/runtime/JSCJSValueInlines.h
Source/JavaScriptCore/runtime/RuntimeType.cpp
Source/JavaScriptCore/runtime/RuntimeType.h
Source/JavaScriptCore/runtime/TypeSet.cpp

index 60291b0..24af717 100644 (file)
@@ -1,3 +1,191 @@
+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):
+
 2016-04-24  Yusuke Suzuki  <utatane.tea@gmail.com>
 
         [JSC] Optimize JSON.parse string fast path
index da9f57c..126a468 100644 (file)
@@ -58,8 +58,8 @@ static RefPtr<InspectorValue> jsToInspectorValue(ExecState& scriptState, JSValue
         return InspectorValue::create(value.asBoolean());
     if (value.isNumber() && value.isDouble())
         return InspectorValue::create(value.asNumber());
-    if (value.isNumber() && value.isMachineInt())
-        return InspectorValue::create(static_cast<int>(value.asMachineInt()));
+    if (value.isNumber() && value.isAnyInt())
+        return InspectorValue::create(static_cast<int>(value.asAnyInt()));
     if (value.isString())
         return InspectorValue::create(value.getString(&scriptState));
 
index 68fca8b..0e602ff 100644 (file)
@@ -168,7 +168,7 @@ void dumpSpeculation(PrintStream& out, SpeculatedType value)
             isTop = false;
     }
     
-    if (value == SpecInt32)
+    if (value == SpecInt32Only)
         myOut.print("Int32");
     else {
         if (value & SpecBoolInt32)
@@ -182,14 +182,14 @@ void dumpSpeculation(PrintStream& out, SpeculatedType value)
             isTop = false;
     }
     
-    if (value & SpecInt52)
+    if (value & SpecInt52Only)
         myOut.print("Int52");
         
     if ((value & SpecBytecodeDouble) == SpecBytecodeDouble)
         myOut.print("Bytecodedouble");
     else {
-        if (value & SpecInt52AsDouble)
-            myOut.print("Int52asdouble");
+        if (value & SpecAnyIntAsDouble)
+            myOut.print("AnyIntAsDouble");
         else
             isTop = false;
         
@@ -274,12 +274,12 @@ static const char* speculationToAbbreviatedString(SpeculatedType prediction)
         return "<BoolInt32>";
     if (isInt32Speculation(prediction))
         return "<Int32>";
-    if (isInt52AsDoubleSpeculation(prediction))
-        return "<Int52AsDouble>";
+    if (isAnyIntAsDoubleSpeculation(prediction))
+        return "<AnyIntAsDouble>";
     if (isInt52Speculation(prediction))
         return "<Int52>";
-    if (isMachineIntSpeculation(prediction))
-        return "<MachineInt>";
+    if (isAnyIntSpeculation(prediction))
+        return "<AnyInt>";
     if (isDoubleSpeculation(prediction))
         return "<Double>";
     if (isFullNumberSpeculation(prediction))
@@ -393,8 +393,8 @@ SpeculatedType speculationFromValue(JSValue value)
         double number = value.asNumber();
         if (number != number)
             return SpecDoublePureNaN;
-        if (value.isMachineInt())
-            return SpecInt52AsDouble;
+        if (value.isAnyInt())
+            return SpecAnyIntAsDouble;
         return SpecNonIntAsDouble;
     }
     if (value.isCell())
@@ -439,8 +439,8 @@ TypedArrayType typedArrayTypeFromSpeculation(SpeculatedType type)
 
 SpeculatedType leastUpperBoundOfStrictlyEquivalentSpeculations(SpeculatedType type)
 {
-    if (type & SpecInteger)
-        type |= SpecInteger;
+    if (type & (SpecAnyInt | SpecAnyIntAsDouble))
+        type |= (SpecAnyInt | SpecAnyIntAsDouble);
     if (type & SpecString)
         type |= SpecString;
     return type;
@@ -526,7 +526,7 @@ SpeculatedType typeOfDoubleNegation(SpeculatedType value)
     // 0xefff000000000000 (pure) - 0xffff000000000000 (impure)
     if (value & SpecDoubleNaN)
         value |= SpecDoubleNaN;
-    // We could get negative zero, which mixes SpecInt52AsDouble and SpecNotIntAsDouble.
+    // We could get negative zero, which mixes SpecAnyIntAsDouble and SpecNotIntAsDouble.
     // We could also overflow a large negative int into something that is no longer
     // representable as an int.
     if (value & SpecDoubleReal)
@@ -547,7 +547,7 @@ SpeculatedType typeOfDoubleRounding(SpeculatedType value)
         value |= SpecDoubleNaN;
     // We might lose bits, which leads to a value becoming integer-representable.
     if (value & SpecNonIntAsDouble)
-        value |= SpecInt52AsDouble;
+        value |= SpecAnyIntAsDouble;
     return value;
 }
 
index e8f7b7d..f06a4cb 100644 (file)
@@ -66,29 +66,28 @@ static const SpeculatedType SpecCellOther          = 1u << 20; // It's definitel
 static const SpeculatedType SpecCell               = SpecObject | SpecString | SpecSymbol | SpecCellOther; // It's definitely a JSCell.
 static const SpeculatedType SpecBoolInt32          = 1u << 21; // It's definitely an Int32 with value 0 or 1.
 static const SpeculatedType SpecNonBoolInt32       = 1u << 22; // It's definitely an Int32 with value other than 0 or 1.
-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.
+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.
 static const SpeculatedType SpecNonIntAsDouble     = 1u << 25; // It's definitely not an Int52 but it's a real number and it's a double.
-static const SpeculatedType SpecDoubleReal         = SpecNonIntAsDouble | SpecInt52AsDouble; // It's definitely a non-NaN double.
+static const SpeculatedType SpecDoubleReal         = SpecNonIntAsDouble | SpecAnyIntAsDouble; // It's definitely a non-NaN double.
 static const SpeculatedType SpecDoublePureNaN      = 1u << 26; // It's definitely a NaN that is sae to tag (i.e. pure).
 static const SpeculatedType SpecDoubleImpureNaN    = 1u << 27; // It's definitely a NaN that is unsafe to tag (i.e. impure).
 static const SpeculatedType SpecDoubleNaN          = SpecDoublePureNaN | SpecDoubleImpureNaN; // It's definitely some kind of NaN.
 static const SpeculatedType SpecBytecodeDouble     = SpecDoubleReal | SpecDoublePureNaN; // It's either a non-NaN or a NaN double, but it's definitely not impure NaN.
 static const SpeculatedType SpecFullDouble         = SpecDoubleReal | SpecDoubleNaN; // It's either a non-NaN or a NaN double.
-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.
+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.
 static const SpeculatedType SpecBoolean            = 1u << 28; // It's definitely a Boolean.
 static const SpeculatedType SpecOther              = 1u << 29; // It's definitely either Null or Undefined.
 static const SpeculatedType SpecMisc               = SpecBoolean | SpecOther; // It's definitely either a boolean, Null, or Undefined.
-static const SpeculatedType SpecHeapTop            = SpecCell | SpecBytecodeNumber | SpecMisc; // It can be any of the above, except for SpecInt52 and SpecDoubleImpureNaN.
+static const SpeculatedType SpecHeapTop            = SpecCell | SpecBytecodeNumber | SpecMisc; // It can be any of the above, except for SpecInt52Only and SpecDoubleImpureNaN.
 static const SpeculatedType SpecPrimitive          = SpecString | SpecSymbol | SpecBytecodeNumber | SpecMisc; // It's any non-Object JSValue.
 static const SpeculatedType SpecEmpty              = 1u << 30; // It's definitely an empty value marker.
-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.
+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.
 static const SpeculatedType SpecFullTop            = SpecBytecodeTop | SpecFullNumber; // It can be anything that bytecode could see plus exotic encodings of numbers.
 
 typedef bool (*SpeculatedTypeChecker)(SpeculatedType);
@@ -288,22 +287,22 @@ inline bool isBoolInt32Speculation(SpeculatedType value)
 
 inline bool isInt32Speculation(SpeculatedType value)
 {
-    return value && !(value & ~SpecInt32);
+    return value && !(value & ~SpecInt32Only);
 }
 
 inline bool isInt32OrBooleanSpeculation(SpeculatedType value)
 {
-    return value && !(value & ~(SpecBoolean | SpecInt32));
+    return value && !(value & ~(SpecBoolean | SpecInt32Only));
 }
 
 inline bool isInt32SpeculationForArithmetic(SpeculatedType value)
 {
-    return !(value & (SpecFullDouble | SpecInt52));
+    return !(value & (SpecFullDouble | SpecInt52Only));
 }
 
 inline bool isInt32OrBooleanSpeculationForArithmetic(SpeculatedType value)
 {
-    return !(value & (SpecFullDouble | SpecInt52));
+    return !(value & (SpecFullDouble | SpecInt52Only));
 }
 
 inline bool isInt32OrBooleanSpeculationExpectingDefined(SpeculatedType value)
@@ -313,22 +312,17 @@ inline bool isInt32OrBooleanSpeculationExpectingDefined(SpeculatedType value)
 
 inline bool isInt52Speculation(SpeculatedType value)
 {
-    return value == SpecInt52;
+    return value == SpecInt52Only;
 }
 
-inline bool isMachineIntSpeculation(SpeculatedType value)
+inline bool isAnyIntSpeculation(SpeculatedType value)
 {
-    return !!value && (value & SpecMachineInt) == value;
+    return !!value && (value & SpecAnyInt) == value;
 }
 
-inline bool isInt52AsDoubleSpeculation(SpeculatedType value)
+inline bool isAnyIntAsDoubleSpeculation(SpeculatedType value)
 {
-    return value == SpecInt52AsDouble;
-}
-
-inline bool isIntegerSpeculation(SpeculatedType value)
-{
-    return !!value && (value & SpecInteger) == value;
+    return value == SpecAnyIntAsDouble;
 }
 
 inline bool isDoubleRealSpeculation(SpeculatedType value)
index 45da2c2..7abe5b8 100644 (file)
@@ -237,7 +237,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
         // https://bugs.webkit.org/show_bug.cgi?id=143071
         clobberWorld(node->origin.semantic, clobberLimit);
         LoadVarargsData* data = node->loadVarargsData();
-        m_state.variables().operand(data->count).setType(SpecInt32);
+        m_state.variables().operand(data->count).setType(SpecInt32Only);
         for (unsigned i = data->limit - 1; i--;)
             m_state.variables().operand(data->start.offset() + i).makeHeapTop();
         break;
@@ -251,7 +251,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
     case BitURShift: {
         if (node->child1().useKind() == UntypedUse || node->child2().useKind() == UntypedUse) {
             clobberWorld(node->origin.semantic, clobberLimit);
-            forNode(node).setType(m_graph, SpecInt32);
+            forNode(node).setType(m_graph, SpecInt32Only);
             break;
         }
 
@@ -293,7 +293,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
             break;
         }
         
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }
         
@@ -301,11 +301,11 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
         JSValue child = forNode(node->child1()).value();
         if (doesOverflow(node->arithMode())) {
             if (enableInt52()) {
-                if (child && child.isMachineInt()) {
-                    setConstant(node, jsNumber(child.asMachineInt()));
+                if (child && child.isAnyInt()) {
+                    setConstant(node, jsNumber(child.asAnyInt()));
                     break;
                 }
-                forNode(node).setType(SpecMachineInt);
+                forNode(node).setType(SpecAnyInt);
                 break;
             }
             if (child && child.isInt32()) {
@@ -313,7 +313,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
                 setConstant(node, jsNumber(value));
                 break;
             }
-            forNode(node).setType(SpecInt52AsDouble);
+            forNode(node).setType(SpecAnyIntAsDouble);
             break;
         }
         if (child && child.isInt32()) {
@@ -323,7 +323,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
                 break;
             }
         }
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }
         
@@ -357,7 +357,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
                 break;
             }
         }
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }
             
@@ -386,7 +386,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
             break;
         }
         
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }
         
@@ -441,12 +441,12 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
         
     case Int52Rep: {
         JSValue child = forNode(node->child1()).value();
-        if (child && child.isMachineInt()) {
+        if (child && child.isAnyInt()) {
             setConstant(node, child);
             break;
         }
         
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }
         
@@ -490,17 +490,17 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
                     break;
                 }
             }
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case Int52RepUse:
-            if (left && right && left.isMachineInt() && right.isMachineInt()) {
-                JSValue result = jsNumber(left.asMachineInt() + right.asMachineInt());
-                if (result.isMachineInt()) {
+            if (left && right && left.isAnyInt() && right.isAnyInt()) {
+                JSValue result = jsNumber(left.asAnyInt() + right.asAnyInt());
+                if (result.isAnyInt()) {
                     setConstant(node, result);
                     break;
                 }
             }
-            forNode(node).setType(SpecMachineInt);
+            forNode(node).setType(SpecAnyInt);
             break;
         case DoubleRepUse:
             if (left && right && left.isNumber() && right.isNumber()) {
@@ -525,7 +525,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
             setConstant(node, jsNumber(clz32(value)));
             break;
         }
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }
 
@@ -550,17 +550,17 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
                     break;
                 }
             }
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case Int52RepUse:
-            if (left && right && left.isMachineInt() && right.isMachineInt()) {
-                JSValue result = jsNumber(left.asMachineInt() - right.asMachineInt());
-                if (result.isMachineInt() || !shouldCheckOverflow(node->arithMode())) {
+            if (left && right && left.isAnyInt() && right.isAnyInt()) {
+                JSValue result = jsNumber(left.asAnyInt() - right.asAnyInt());
+                if (result.isAnyInt() || !shouldCheckOverflow(node->arithMode())) {
                     setConstant(node, result);
                     break;
                 }
             }
-            forNode(node).setType(SpecMachineInt);
+            forNode(node).setType(SpecAnyInt);
             break;
         case DoubleRepUse:
             if (left && right && left.isNumber() && right.isNumber()) {
@@ -602,22 +602,22 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
                     break;
                 }
             }
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case Int52RepUse:
-            if (child && child.isMachineInt()) {
+            if (child && child.isAnyInt()) {
                 double doubleResult;
                 if (shouldCheckNegativeZero(node->arithMode()))
                     doubleResult = -child.asNumber();
                 else
                     doubleResult = 0 - child.asNumber();
                 JSValue valueResult = jsNumber(doubleResult);
-                if (valueResult.isMachineInt()) {
+                if (valueResult.isAnyInt()) {
                     setConstant(node, valueResult);
                     break;
                 }
             }
-            forNode(node).setType(SpecMachineInt);
+            forNode(node).setType(SpecAnyInt);
             break;
         case DoubleRepUse:
             if (child && child.isNumber()) {
@@ -654,20 +654,20 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
                     break;
                 }
             }
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case Int52RepUse:
-            if (left && right && left.isMachineInt() && right.isMachineInt()) {
+            if (left && right && left.isAnyInt() && right.isAnyInt()) {
                 double doubleResult = left.asNumber() * right.asNumber();
                 if (!shouldCheckNegativeZero(node->arithMode()))
                     doubleResult += 0;
                 JSValue valueResult = jsNumber(doubleResult);
-                if (valueResult.isMachineInt()) {
+                if (valueResult.isAnyInt()) {
                     setConstant(node, valueResult);
                     break;
                 }
             }
-            forNode(node).setType(SpecMachineInt);
+            forNode(node).setType(SpecAnyInt);
             break;
         case DoubleRepUse:
             if (left && right && left.isNumber() && right.isNumber()) {
@@ -706,7 +706,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
                     break;
                 }
             }
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case DoubleRepUse:
             if (left && right && left.isNumber() && right.isNumber()) {
@@ -745,7 +745,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
                     break;
                 }
             }
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case DoubleRepUse:
             if (left && right && left.isNumber() && right.isNumber()) {
@@ -772,7 +772,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
                 setConstant(node, jsNumber(std::min(left.asInt32(), right.asInt32())));
                 break;
             }
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case DoubleRepUse:
             if (left && right && left.isNumber() && right.isNumber()) {
@@ -801,7 +801,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
                 setConstant(node, jsNumber(std::max(left.asInt32(), right.asInt32())));
                 break;
             }
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case DoubleRepUse:
             if (left && right && left.isNumber() && right.isNumber()) {
@@ -832,7 +832,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
                     break;
                 }
             }
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case DoubleRepUse:
             if (child && child.isNumber()) {
@@ -908,7 +908,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
             }
         }
         if (producesInteger(node->arithRoundingMode()))
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
         else
             forNode(node).setType(typeOfDoubleRounding(forNode(node->child1()).m_type));
         break;
@@ -1462,7 +1462,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
     }
         
     case StringCharCodeAt:
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
         
     case StringFromCharCode:
@@ -1522,7 +1522,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
                 clobberWorld(node->origin.semantic, clobberLimit);
                 forNode(node).makeHeapTop();
             } else
-                forNode(node).setType(SpecInt32);
+                forNode(node).setType(SpecInt32Only);
             break;
         case Array::Double:
             if (node->arrayMode().isOutOfBounds()) {
@@ -1541,30 +1541,30 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
             forNode(node).makeHeapTop();
             break;
         case Array::Int8Array:
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case Array::Int16Array:
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case Array::Int32Array:
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case Array::Uint8Array:
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case Array::Uint8ClampedArray:
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case Array::Uint16Array:
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case Array::Uint32Array:
             if (node->shouldSpeculateInt32())
-                forNode(node).setType(SpecInt32);
-            else if (enableInt52() && node->shouldSpeculateMachineInt())
-                forNode(node).setType(SpecMachineInt);
+                forNode(node).setType(SpecInt32Only);
+            else if (enableInt52() && node->shouldSpeculateAnyInt())
+                forNode(node).setType(SpecAnyInt);
             else
-                forNode(node).setType(SpecInt52AsDouble);
+                forNode(node).setType(SpecAnyIntAsDouble);
             break;
         case Array::Float32Array:
             forNode(node).setType(SpecFullDouble);
@@ -1967,11 +1967,11 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
         break;
         
     case GetArgumentCount:
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
         
     case GetRestLength:
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
         
     case GetGetter: {
@@ -2124,7 +2124,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
             setConstant(node, jsNumber(view->length()));
             break;
         }
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }
 
@@ -2350,7 +2350,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
             setConstant(node, jsNumber(view->byteOffset()));
             break;
         }
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }
         
@@ -2632,7 +2632,7 @@ bool AbstractInterpreter<AbstractStateType>::executeEffects(unsigned clobberLimi
     }
             
     case GetEnumerableLength: {
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }
     case HasGenericProperty: {
index dced7c5..b95dfa5 100644 (file)
@@ -130,7 +130,7 @@ void AbstractValue::set(Graph& graph, const InferredType::Descriptor& descriptor
         setType(SpecOther);
         return;
     case InferredType::Int32:
-        setType(SpecInt32);
+        setType(SpecInt32Only);
         return;
     case InferredType::Number:
         setType(SpecBytecodeNumber);
@@ -178,23 +178,23 @@ void AbstractValue::fixTypeForRepresentation(Graph& graph, NodeFlags representat
             if (m_value.isInt32())
                 m_value = jsDoubleNumber(m_value.asNumber());
         }
-        if (m_type & SpecMachineInt) {
-            m_type &= ~SpecMachineInt;
-            m_type |= SpecInt52AsDouble;
+        if (m_type & SpecAnyInt) {
+            m_type &= ~SpecAnyInt;
+            m_type |= SpecAnyIntAsDouble;
         }
         if (m_type & ~SpecFullDouble)
             DFG_CRASH(graph, node, toCString("Abstract value ", *this, " for double node has type outside SpecFullDouble.\n").data());
     } else if (representation == NodeResultInt52) {
-        if (m_type & SpecInt52AsDouble) {
-            m_type &= ~SpecInt52AsDouble;
-            m_type |= SpecInt52;
+        if (m_type & SpecAnyIntAsDouble) {
+            m_type &= ~SpecAnyIntAsDouble;
+            m_type |= SpecInt52Only;
         }
-        if (m_type & ~SpecMachineInt)
-            DFG_CRASH(graph, node, toCString("Abstract value ", *this, " for int52 node has type outside SpecMachineInt.\n").data());
+        if (m_type & ~SpecAnyInt)
+            DFG_CRASH(graph, node, toCString("Abstract value ", *this, " for int52 node has type outside SpecAnyInt.\n").data());
     } else {
-        if (m_type & SpecInt52) {
-            m_type &= ~SpecInt52;
-            m_type |= SpecInt52AsDouble;
+        if (m_type & SpecInt52Only) {
+            m_type &= ~SpecInt52Only;
+            m_type |= SpecAnyIntAsDouble;
         }
         if (m_type & ~SpecBytecodeTop)
             DFG_CRASH(graph, node, toCString("Abstract value ", *this, " for value node has type outside SpecBytecodeTop.\n").data());
@@ -480,8 +480,8 @@ void AbstractValue::checkConsistency() const
         SpeculatedType type = m_type;
         // This relaxes the assertion below a bit, since we don't know the representation of the
         // node.
-        if (type & SpecInt52)
-            type |= SpecInt52AsDouble;
+        if (type & SpecInt52Only)
+            type |= SpecAnyIntAsDouble;
         ASSERT(mergeSpeculations(type, speculationFromValue(m_value)) == type);
     }
     
@@ -502,7 +502,7 @@ ResultType AbstractValue::resultType() const
     ASSERT(isType(SpecBytecodeTop));
     if (isType(SpecBoolean))
         return ResultType::booleanType();
-    if (isType(SpecInt32))
+    if (isType(SpecInt32Only))
         return ResultType::numberTypeIsInt32();
     if (isType(SpecBytecodeNumber))
         return ResultType::numberType();
index 4808428..d514300 100644 (file)
@@ -376,7 +376,7 @@ struct AbstractValue {
     // abstract value that consists of the union of the set of all non-cell values
     // and the set of cell values that have the given structure. This abstract
     // value is then the intersection of the m_structure and the set of values
-    // whose type is m_type. So, for example if m_type is SpecFinal|SpecInt32 and
+    // whose type is m_type. So, for example if m_type is SpecFinal|SpecInt32Only and
     // m_structure is [0x12345] then this abstract value corresponds to the set of
     // all integers unified with the set of all objects with structure 0x12345.
     SpeculatedType m_type;
@@ -419,12 +419,12 @@ private:
         if (isHeapTop())
             return true;
         
-        // Constant folding always represents Int52's in a double (i.e. Int52AsDouble).
-        // So speculationFromValue(value) for an Int52 value will return Int52AsDouble,
+        // Constant folding always represents Int52's in a double (i.e. AnyIntAsDouble).
+        // So speculationFromValue(value) for an Int52 value will return AnyIntAsDouble,
         // and that's fine - the type validates just fine.
         SpeculatedType type = m_type;
-        if (type & SpecInt52)
-            type |= SpecInt52AsDouble;
+        if (type & SpecInt52Only)
+            type |= SpecAnyIntAsDouble;
         
         if (mergeSpeculations(type, speculationFromValue(value)) != type)
             return false;
index 5d512b1..75c21b3 100644 (file)
@@ -76,17 +76,17 @@ Node* emitCodeToGetArgumentsArrayLength(
     
     Node* argumentCount;
     if (!inlineCallFrame)
-        argumentCount = insertionSet.insertNode(nodeIndex, SpecInt32, GetArgumentCount, origin);
+        argumentCount = insertionSet.insertNode(nodeIndex, SpecInt32Only, GetArgumentCount, origin);
     else {
         VirtualRegister argumentCountRegister(inlineCallFrame->stackOffset + JSStack::ArgumentCount);
         
         argumentCount = insertionSet.insertNode(
-            nodeIndex, SpecInt32, GetStack, origin,
+            nodeIndex, SpecInt32Only, GetStack, origin,
             OpInfo(graph.m_stackAccessData.add(argumentCountRegister, FlushedInt32)));
     }
     
     return insertionSet.insertNode(
-        nodeIndex, SpecInt32, ArithSub, origin, OpInfo(Arith::Unchecked),
+        nodeIndex, SpecInt32Only, ArithSub, origin, OpInfo(Arith::Unchecked),
         Edge(argumentCount, Int32Use),
         insertionSet.insertConstantForUse(
             nodeIndex, origin, jsNumber(1), Int32Use));
index 311257a..c8c4059 100644 (file)
@@ -1744,7 +1744,7 @@ bool ByteCodeParser::handleInlining(
                     // This is pretty lame, but it will force the count to be flushed as an int. This doesn't
                     // matter very much, since our use of a SetArgument and Flushes for this local slot is
                     // mostly just a formality.
-                    countVariable->predict(SpecInt32);
+                    countVariable->predict(SpecInt32Only);
                     countVariable->mergeIsProfitableToUnbox(true);
                     Node* setArgumentCount = addToGraph(SetArgument, OpInfo(countVariable));
                     m_currentBlock->variablesAtTail.setOperand(countVariable->local(), setArgumentCount);
@@ -2346,7 +2346,7 @@ bool ByteCodeParser::handleIntrinsicCall(Node* callee, int resultOperand, Intrin
         for (int i = 1; i < argumentCountIncludingThis; ++i) {
             Node* node = get(virtualRegisterForArgument(i, registerOffset));
             if (node->hasHeapPrediction())
-                node->setHeapPrediction(SpecInt32);
+                node->setHeapPrediction(SpecInt32Only);
         }
         set(VirtualRegister(resultOperand), addToGraph(JSConstant, OpInfo(m_constantUndefined)));
         return true;
index 344827e..63fc60c 100644 (file)
@@ -219,7 +219,7 @@ private:
                     node->setArithMode(Arith::CheckOverflowAndNegativeZero);
                 break;
             }
-            if (m_graph.unaryArithShouldSpeculateMachineInt(node, FixupPass)) {
+            if (m_graph.unaryArithShouldSpeculateAnyInt(node, FixupPass)) {
                 fixEdge<Int52RepUse>(node->child1());
                 if (bytecodeCanIgnoreNegativeZero(node->arithNodeFlags()))
                     node->setArithMode(Arith::CheckOverflow);
@@ -255,7 +255,7 @@ private:
                     node->setArithMode(Arith::CheckOverflowAndNegativeZero);
                 break;
             }
-            if (m_graph.binaryArithShouldSpeculateMachineInt(node, FixupPass)) {
+            if (m_graph.binaryArithShouldSpeculateAnyInt(node, FixupPass)) {
                 fixEdge<Int52RepUse>(leftChild);
                 fixEdge<Int52RepUse>(rightChild);
                 if (bytecodeCanIgnoreNegativeZero(node->arithNodeFlags())
@@ -446,7 +446,7 @@ private:
                 break;
             }
             if (enableInt52()
-                && Node::shouldSpeculateMachineInt(node->child1().node(), node->child2().node())) {
+                && Node::shouldSpeculateAnyInt(node->child1().node(), node->child2().node())) {
                 fixEdge<Int52RepUse>(node->child1());
                 fixEdge<Int52RepUse>(node->child2());
                 node->clearFlags(NodeMustGenerate);
@@ -551,7 +551,7 @@ private:
                 break;
             }
             if (enableInt52()
-                && Node::shouldSpeculateMachineInt(node->child1().node(), node->child2().node())) {
+                && Node::shouldSpeculateAnyInt(node->child1().node(), node->child2().node())) {
                 fixEdge<Int52RepUse>(node->child1());
                 fixEdge<Int52RepUse>(node->child2());
                 break;
@@ -763,7 +763,7 @@ private:
             case Array::Uint32Array:
                 if (node->shouldSpeculateInt32())
                     break;
-                if (node->shouldSpeculateMachineInt() && enableInt52())
+                if (node->shouldSpeculateAnyInt() && enableInt52())
                     node->setResult(NodeResultInt52);
                 else
                     node->setResult(NodeResultDouble);
@@ -829,7 +829,7 @@ private:
                 fixEdge<Int32Use>(child2);
                 if (child3->shouldSpeculateInt32())
                     fixIntOrBooleanEdge(child3);
-                else if (child3->shouldSpeculateMachineInt())
+                else if (child3->shouldSpeculateAnyInt())
                     fixEdge<Int52RepUse>(child3);
                 else
                     fixDoubleOrBooleanEdge(child3);
@@ -869,7 +869,7 @@ private:
                 node->arrayMode().refine(
                     m_graph, node,
                     node->child1()->prediction() & SpecCell,
-                    SpecInt32,
+                    SpecInt32Only,
                     node->child2()->prediction()));
             blessArrayOperation(node->child1(), Edge(), node->child3());
             fixEdge<KnownCellUse>(node->child1());
@@ -1433,13 +1433,13 @@ private:
 
             RefPtr<TypeSet> typeSet = node->typeLocation()->m_instructionTypeSet;
             RuntimeTypeMask seenTypes = typeSet->seenTypes();
-            if (typeSet->doesTypeConformTo(TypeMachineInt)) {
+            if (typeSet->doesTypeConformTo(TypeAnyInt)) {
                 if (node->child1()->shouldSpeculateInt32())
                     fixEdge<Int32Use>(node->child1());
                 else
-                    fixEdge<MachineIntUse>(node->child1());
+                    fixEdge<AnyIntUse>(node->child1());
                 node->remove();
-            } else if (typeSet->doesTypeConformTo(TypeNumber | TypeMachineInt)) {
+            } else if (typeSet->doesTypeConformTo(TypeNumber | TypeAnyInt)) {
                 fixEdge<NumberUse>(node->child1());
                 node->remove();
             } else if (typeSet->doesTypeConformTo(TypeString)) {
@@ -1678,7 +1678,7 @@ private:
                 return;
             }
 
-            if (enableInt52() && node->child1()->shouldSpeculateMachineInt()) {
+            if (enableInt52() && node->child1()->shouldSpeculateAnyInt()) {
                 fixEdge<Int52RepUse>(node->child1());
                 node->convertToIdentity();
                 node->setResult(NodeResultInt52);
@@ -2032,7 +2032,7 @@ private:
                 m_profitabilityChanged |= variable->mergeIsProfitableToUnbox(true);
             break;
         case Int52RepUse:
-            if (isMachineIntSpeculation(variable->prediction()))
+            if (isAnyIntSpeculation(variable->prediction()))
                 m_profitabilityChanged |= variable->mergeIsProfitableToUnbox(true);
             break;
         case CellUse:
@@ -2109,14 +2109,14 @@ private:
         }
         
         UseKind useKind;
-        if (node->shouldSpeculateMachineInt())
+        if (node->shouldSpeculateAnyInt())
             useKind = Int52RepUse;
         else if (node->shouldSpeculateNumber())
             useKind = DoubleRepUse;
         else
             useKind = NotCellUse;
         Node* newNode = m_insertionSet.insertNode(
-            m_indexInBlock, SpecInt32, ValueToInt32, m_currentNode->origin,
+            m_indexInBlock, SpecInt32Only, ValueToInt32, m_currentNode->origin,
             Edge(node, useKind));
         observeUseKindOnNode(node, useKind);
         
@@ -2137,7 +2137,7 @@ private:
         else
             useKind = UntypedUse;
         Node* newNode = m_insertionSet.insertNode(
-            m_indexInBlock, SpecInt32, BooleanToNumber, m_currentNode->origin,
+            m_indexInBlock, SpecInt32Only, BooleanToNumber, m_currentNode->origin,
             Edge(node, useKind));
         observeUseKindOnNode(node, useKind);
         
@@ -2158,7 +2158,7 @@ private:
         else
             useKind = UntypedUse;
         Node* newNode = m_insertionSet.insertNode(
-            m_indexInBlock, SpecInt32, BooleanToNumber, m_currentNode->origin,
+            m_indexInBlock, SpecInt32Only, BooleanToNumber, m_currentNode->origin,
             Edge(node, useKind));
         observeUseKindOnNode(node, useKind);
         
@@ -2176,7 +2176,7 @@ private:
         value = jsNumber(JSC::toInt32(value.asNumber()));
         ASSERT(value.isInt32());
         edge.setNode(m_insertionSet.insertNode(
-            m_indexInBlock, SpecInt32, JSConstant, m_currentNode->origin,
+            m_indexInBlock, SpecInt32Only, JSConstant, m_currentNode->origin,
             OpInfo(m_graph.freeze(value))));
     }
     
@@ -2206,7 +2206,7 @@ private:
             return true;
         }
         
-        if (m_graph.addShouldSpeculateMachineInt(node)) {
+        if (m_graph.addShouldSpeculateAnyInt(node)) {
             fixEdge<Int52RepUse>(node->child1());
             fixEdge<Int52RepUse>(node->child2());
             node->setArithMode(Arith::CheckOverflow);
@@ -2279,7 +2279,7 @@ private:
     {
         Node* storage = checkArray(arrayMode, origin, child, 0, lengthNeedsStorage);
         return m_insertionSet.insertNode(
-            m_indexInBlock, SpecInt32, GetArrayLength, origin,
+            m_indexInBlock, SpecInt32Only, GetArrayLength, origin,
             OpInfo(arrayMode.asWord()), Edge(child, KnownCellUse), Edge(storage));
     }
     
@@ -2369,7 +2369,7 @@ private:
                     switch (edge.useKind()) {
                     case DoubleRepUse:
                     case DoubleRepRealUse:
-                    case DoubleRepMachineIntUse: {
+                    case DoubleRepAnyIntUse: {
                         if (edge->hasDoubleResult())
                             break;
             
@@ -2379,7 +2379,7 @@ private:
                                 OpInfo(m_graph.freeze(jsDoubleNumber(edge->asNumber()))));
                         } else if (edge->hasInt52Result()) {
                             result = m_insertionSet.insertNode(
-                                indexForChecks, SpecInt52AsDouble, DoubleRep, originForChecks,
+                                indexForChecks, SpecAnyIntAsDouble, DoubleRep, originForChecks,
                                 Edge(edge.node(), Int52RepUse));
                         } else {
                             UseKind useKind;
@@ -2403,22 +2403,22 @@ private:
                         if (edge->hasInt52Result())
                             break;
             
-                        if (edge->isMachineIntConstant()) {
+                        if (edge->isAnyIntConstant()) {
                             result = m_insertionSet.insertNode(
-                                indexForChecks, SpecMachineInt, Int52Constant, originForChecks,
+                                indexForChecks, SpecAnyInt, Int52Constant, originForChecks,
                                 OpInfo(edge->constant()));
                         } else if (edge->hasDoubleResult()) {
                             result = m_insertionSet.insertNode(
-                                indexForChecks, SpecMachineInt, Int52Rep, originForChecks,
-                                Edge(edge.node(), DoubleRepMachineIntUse));
+                                indexForChecks, SpecAnyInt, Int52Rep, originForChecks,
+                                Edge(edge.node(), DoubleRepAnyIntUse));
                         } else if (edge->shouldSpeculateInt32ForArithmetic()) {
                             result = m_insertionSet.insertNode(
-                                indexForChecks, SpecInt32, Int52Rep, originForChecks,
+                                indexForChecks, SpecInt32Only, Int52Rep, originForChecks,
                                 Edge(edge.node(), Int32Use));
                         } else {
                             result = m_insertionSet.insertNode(
-                                indexForChecks, SpecMachineInt, Int52Rep, originForChecks,
-                                Edge(edge.node(), MachineIntUse));
+                                indexForChecks, SpecAnyInt, Int52Rep, originForChecks,
+                                Edge(edge.node(), AnyIntUse));
                         }
 
                         edge.setNode(result);
@@ -2435,7 +2435,7 @@ private:
                                 Edge(edge.node(), DoubleRepUse));
                         } else {
                             result = m_insertionSet.insertNode(
-                                indexForChecks, SpecInt32 | SpecInt52AsDouble, ValueRep,
+                                indexForChecks, SpecInt32Only | SpecAnyIntAsDouble, ValueRep,
                                 originForChecks, Edge(edge.node(), Int52RepUse));
                         }
 
index 467db0e..1fa83bf 100644 (file)
@@ -263,7 +263,7 @@ public:
         return addSpeculationMode(add, pass) != DontSpeculateInt32;
     }
     
-    bool addShouldSpeculateMachineInt(Node* add)
+    bool addShouldSpeculateAnyInt(Node* add)
     {
         if (!enableInt52())
             return false;
@@ -271,7 +271,7 @@ public:
         Node* left = add->child1().node();
         Node* right = add->child2().node();
 
-        bool speculation = Node::shouldSpeculateMachineInt(left, right);
+        bool speculation = Node::shouldSpeculateAnyInt(left, right);
         return speculation && !hasExitSite(add, Int52Overflow);
     }
     
@@ -284,7 +284,7 @@ public:
             && node->canSpeculateInt32(node->sourceFor(pass));
     }
     
-    bool binaryArithShouldSpeculateMachineInt(Node* node, PredictionPass pass)
+    bool binaryArithShouldSpeculateAnyInt(Node* node, PredictionPass pass)
     {
         if (!enableInt52())
             return false;
@@ -292,7 +292,7 @@ public:
         Node* left = node->child1().node();
         Node* right = node->child2().node();
 
-        return Node::shouldSpeculateMachineInt(left, right)
+        return Node::shouldSpeculateAnyInt(left, right)
             && node->canSpeculateInt52(pass)
             && !hasExitSite(node, Int52Overflow);
     }
@@ -303,11 +303,11 @@ public:
             && node->canSpeculateInt32(pass);
     }
     
-    bool unaryArithShouldSpeculateMachineInt(Node* node, PredictionPass pass)
+    bool unaryArithShouldSpeculateAnyInt(Node* node, PredictionPass pass)
     {
         if (!enableInt52())
             return false;
-        return node->child1()->shouldSpeculateMachineInt()
+        return node->child1()->shouldSpeculateAnyInt()
             && node->canSpeculateInt52(pass)
             && !hasExitSite(node, Int52Overflow);
     }
index c445e35..e7cebb8 100644 (file)
@@ -118,7 +118,7 @@ void InPlaceAbstractState::initialize()
         
         switch (format) {
         case FlushedInt32:
-            root->valuesAtHead.argument(i).setType(SpecInt32);
+            root->valuesAtHead.argument(i).setType(SpecInt32Only);
             break;
         case FlushedBoolean:
             root->valuesAtHead.argument(i).setType(SpecBoolean);
index 013276b..a9566ea 100644 (file)
@@ -542,7 +542,7 @@ void JITCompiler::noticeOSREntry(BasicBlock& basicBlock, JITCompiler::Label bloc
                 entry->m_localsForcedDouble.set(local);
                 break;
             case FlushedInt52:
-                entry->m_localsForcedMachineInt.set(local);
+                entry->m_localsForcedAnyInt.set(local);
                 break;
             default:
                 break;
index 381cbe0..48f1d55 100644 (file)
@@ -132,10 +132,10 @@ void Node::convertToIdentityOn(Node* child)
         setOpAndDefaultFlags(Int52Rep);
         switch (input) {
         case NodeResultDouble:
-            child1().setUseKind(DoubleRepMachineIntUse);
+            child1().setUseKind(DoubleRepAnyIntUse);
             return;
         case NodeResultJS:
-            child1().setUseKind(MachineIntUse);
+            child1().setUseKind(AnyIntUse);
             return;
         default:
             RELEASE_ASSERT_NOT_REACHED();
index bab1c35..80dbd9b 100644 (file)
@@ -681,14 +681,14 @@ struct Node {
         return asJSValue().asNumber();
     }
      
-    bool isMachineIntConstant()
+    bool isAnyIntConstant()
     {
-        return isConstant() && constant()->value().isMachineInt();
+        return isConstant() && constant()->value().isAnyInt();
     }
      
-    int64_t asMachineInt()
+    int64_t asAnyInt()
     {
-        return asJSValue().asMachineInt();
+        return asJSValue().asAnyInt();
     }
      
     bool isBooleanConstant()
@@ -1920,9 +1920,9 @@ struct Node {
         return isInt32OrBooleanSpeculationExpectingDefined(prediction());
     }
     
-    bool shouldSpeculateMachineInt()
+    bool shouldSpeculateAnyInt()
     {
-        return isMachineIntSpeculation(prediction());
+        return isAnyIntSpeculation(prediction());
     }
     
     bool shouldSpeculateDouble()
@@ -2153,9 +2153,9 @@ struct Node {
             && op2->shouldSpeculateInt32OrBooleanExpectingDefined();
     }
     
-    static bool shouldSpeculateMachineInt(Node* op1, Node* op2)
+    static bool shouldSpeculateAnyInt(Node* op1, Node* op2)
     {
-        return op1->shouldSpeculateMachineInt() && op2->shouldSpeculateMachineInt();
+        return op1->shouldSpeculateAnyInt() && op2->shouldSpeculateAnyInt();
     }
     
     static bool shouldSpeculateNumber(Node* op1, Node* op2)
index 80e6880..b5cf7cc 100644 (file)
@@ -67,7 +67,7 @@ void OSREntryData::dumpInContext(PrintStream& out, DumpContext* context) const
             out.print("overwritten");
         if (reg.isLocal() && m_localsForcedDouble.get(reg.toLocal()))
             out.print(", forced double");
-        if (reg.isLocal() && m_localsForcedMachineInt.get(reg.toLocal()))
+        if (reg.isLocal() && m_localsForcedAnyInt.get(reg.toLocal()))
             out.print(", forced machine int");
         out.print(")");
     };
@@ -213,8 +213,8 @@ void* prepareOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIn
             }
             continue;
         }
-        if (entry->m_localsForcedMachineInt.get(local)) {
-            if (!exec->registers()[localOffset].asanUnsafeJSValue().isMachineInt()) {
+        if (entry->m_localsForcedAnyInt.get(local)) {
+            if (!exec->registers()[localOffset].asanUnsafeJSValue().isAnyInt()) {
                 if (Options::verboseOSR()) {
                     dataLog(
                         "    OSR failed because variable ", localOffset, " is ",
@@ -285,8 +285,8 @@ void* prepareOSREntry(ExecState* exec, CodeBlock* codeBlock, unsigned bytecodeIn
                 continue;
             }
             
-            if (entry->m_localsForcedMachineInt.get(reg.toLocal())) {
-                *bitwise_cast<int64_t*>(pivot + index) = exec->registers()[reg.offset()].asanUnsafeJSValue().asMachineInt() << JSValue::int52ShiftAmount;
+            if (entry->m_localsForcedAnyInt.get(reg.toLocal())) {
+                *bitwise_cast<int64_t*>(pivot + index) = exec->registers()[reg.offset()].asanUnsafeJSValue().asAnyInt() << JSValue::int52ShiftAmount;
                 continue;
             }
         }
index 04aaabf..df5d11d 100644 (file)
@@ -57,7 +57,7 @@ struct OSREntryData {
     Operands<AbstractValue> m_expectedValues;
     // Use bitvectors here because they tend to only require one word.
     BitVector m_localsForcedDouble;
-    BitVector m_localsForcedMachineInt;
+    BitVector m_localsForcedAnyInt;
     Vector<OSREntryReshuffling> m_reshufflings;
     BitVector m_machineStackUsed;
     
index f09dc54..0972f2a 100644 (file)
@@ -155,8 +155,8 @@ private:
         case GetLocal: {
             VariableAccessData* variable = node->variableAccessData();
             SpeculatedType prediction = variable->prediction();
-            if (!variable->couldRepresentInt52() && (prediction & SpecInt52))
-                prediction = (prediction | SpecInt52AsDouble) & ~SpecInt52;
+            if (!variable->couldRepresentInt52() && (prediction & SpecInt52Only))
+                prediction = (prediction | SpecAnyIntAsDouble) & ~SpecInt52Only;
             if (prediction)
                 changed |= mergePrediction(prediction);
             break;
@@ -170,9 +170,9 @@ private:
 
         case UInt32ToNumber: {
             if (node->canSpeculateInt32(m_pass))
-                changed |= mergePrediction(SpecInt32);
+                changed |= mergePrediction(SpecInt32Only);
             else if (enableInt52())
-                changed |= mergePrediction(SpecMachineInt);
+                changed |= mergePrediction(SpecAnyInt);
             else
                 changed |= mergePrediction(SpecBytecodeNumber);
             break;
@@ -186,9 +186,9 @@ private:
                 if (isFullNumberOrBooleanSpeculationExpectingDefined(left)
                     && isFullNumberOrBooleanSpeculationExpectingDefined(right)) {
                     if (m_graph.addSpeculationMode(node, m_pass) != DontSpeculateInt32)
-                        changed |= mergePrediction(SpecInt32);
-                    else if (m_graph.addShouldSpeculateMachineInt(node))
-                        changed |= mergePrediction(SpecInt52);
+                        changed |= mergePrediction(SpecInt32Only);
+                    else if (m_graph.addShouldSpeculateAnyInt(node))
+                        changed |= mergePrediction(SpecInt52Only);
                     else
                         changed |= mergePrediction(speculatedDoubleTypeForPredictions(left, right));
                 } else if (
@@ -197,7 +197,7 @@ private:
                     // left or right is definitely something other than a number.
                     changed |= mergePrediction(SpecString);
                 } else
-                    changed |= mergePrediction(SpecString | SpecInt32 | SpecBytecodeDouble);
+                    changed |= mergePrediction(SpecString | SpecInt32Only | SpecBytecodeDouble);
             }
             break;
         }
@@ -208,9 +208,9 @@ private:
             
             if (left && right) {
                 if (m_graph.addSpeculationMode(node, m_pass) != DontSpeculateInt32)
-                    changed |= mergePrediction(SpecInt32);
-                else if (m_graph.addShouldSpeculateMachineInt(node))
-                    changed |= mergePrediction(SpecInt52);
+                    changed |= mergePrediction(SpecInt32Only);
+                else if (m_graph.addShouldSpeculateAnyInt(node))
+                    changed |= mergePrediction(SpecInt52Only);
                 else
                     changed |= mergePrediction(speculatedDoubleTypeForPredictions(left, right));
             }
@@ -225,13 +225,13 @@ private:
                 if (isFullNumberOrBooleanSpeculationExpectingDefined(left)
                     && isFullNumberOrBooleanSpeculationExpectingDefined(right)) {
                     if (m_graph.addSpeculationMode(node, m_pass) != DontSpeculateInt32)
-                        changed |= mergePrediction(SpecInt32);
-                    else if (m_graph.addShouldSpeculateMachineInt(node))
-                        changed |= mergePrediction(SpecInt52);
+                        changed |= mergePrediction(SpecInt32Only);
+                    else if (m_graph.addShouldSpeculateAnyInt(node))
+                        changed |= mergePrediction(SpecInt52Only);
                     else
                         changed |= mergePrediction(speculatedDoubleTypeForPredictions(left, right));
                 } else
-                    changed |= mergePrediction(SpecInt32 | SpecBytecodeDouble);
+                    changed |= mergePrediction(SpecInt32Only | SpecBytecodeDouble);
             }
             break;
         }
@@ -239,9 +239,9 @@ private:
         case ArithNegate:
             if (node->child1()->prediction()) {
                 if (m_graph.unaryArithShouldSpeculateInt32(node, m_pass))
-                    changed |= mergePrediction(SpecInt32);
-                else if (m_graph.unaryArithShouldSpeculateMachineInt(node, m_pass))
-                    changed |= mergePrediction(SpecInt52);
+                    changed |= mergePrediction(SpecInt32Only);
+                else if (m_graph.unaryArithShouldSpeculateAnyInt(node, m_pass))
+                    changed |= mergePrediction(SpecInt52Only);
                 else
                     changed |= mergePrediction(speculatedDoubleTypeForPrediction(node->child1()->prediction()));
             }
@@ -255,7 +255,7 @@ private:
             if (left && right) {
                 if (Node::shouldSpeculateInt32OrBooleanForArithmetic(node->child1().node(), node->child2().node())
                     && node->canSpeculateInt32(m_pass))
-                    changed |= mergePrediction(SpecInt32);
+                    changed |= mergePrediction(SpecInt32Only);
                 else
                     changed |= mergePrediction(speculatedDoubleTypeForPredictions(left, right));
             }
@@ -270,16 +270,16 @@ private:
                 if (isFullNumberOrBooleanSpeculationExpectingDefined(left)
                     && isFullNumberOrBooleanSpeculationExpectingDefined(right)) {
                     if (m_graph.binaryArithShouldSpeculateInt32(node, m_pass))
-                        changed |= mergePrediction(SpecInt32);
-                    else if (m_graph.binaryArithShouldSpeculateMachineInt(node, m_pass))
-                        changed |= mergePrediction(SpecInt52);
+                        changed |= mergePrediction(SpecInt32Only);
+                    else if (m_graph.binaryArithShouldSpeculateAnyInt(node, m_pass))
+                        changed |= mergePrediction(SpecInt52Only);
                     else
                         changed |= mergePrediction(speculatedDoubleTypeForPredictions(left, right));
                 } else {
                     if (node->mayHaveNonIntResult())
-                        changed |= mergePrediction(SpecInt32 | SpecBytecodeDouble);
+                        changed |= mergePrediction(SpecInt32Only | SpecBytecodeDouble);
                     else
-                        changed |= mergePrediction(SpecInt32);
+                        changed |= mergePrediction(SpecInt32Only);
                 }
             }
             break;
@@ -294,11 +294,11 @@ private:
                 if (isFullNumberOrBooleanSpeculationExpectingDefined(left)
                     && isFullNumberOrBooleanSpeculationExpectingDefined(right)) {
                     if (m_graph.binaryArithShouldSpeculateInt32(node, m_pass))
-                        changed |= mergePrediction(SpecInt32);
+                        changed |= mergePrediction(SpecInt32Only);
                     else
                         changed |= mergePrediction(SpecBytecodeDouble);
                 } else
-                    changed |= mergePrediction(SpecInt32 | SpecBytecodeDouble);
+                    changed |= mergePrediction(SpecInt32Only | SpecBytecodeDouble);
             }
             break;
         }
@@ -308,7 +308,7 @@ private:
         case ArithCeil:
         case ArithTrunc: {
             if (isInt32OrBooleanSpeculation(node->getHeapPrediction()) && m_graph.roundShouldSpeculateInt32(node, m_pass))
-                changed |= setPrediction(SpecInt32);
+                changed |= setPrediction(SpecInt32Only);
             else
                 changed |= setPrediction(SpecBytecodeDouble);
             break;
@@ -318,7 +318,7 @@ private:
             SpeculatedType child = node->child1()->prediction();
             if (isInt32OrBooleanSpeculationForArithmetic(child)
                 && node->canSpeculateInt32(m_pass))
-                changed |= mergePrediction(SpecInt32);
+                changed |= mergePrediction(SpecInt32Only);
             else
                 changed |= mergePrediction(speculatedDoubleTypeForPrediction(child));
             break;
@@ -337,9 +337,9 @@ private:
             switch (arrayMode.type()) {
             case Array::Int32:
                 if (arrayMode.isOutOfBounds())
-                    changed |= mergePrediction(node->getHeapPrediction() | SpecInt32);
+                    changed |= mergePrediction(node->getHeapPrediction() | SpecInt32Only);
                 else
-                    changed |= mergePrediction(SpecInt32);
+                    changed |= mergePrediction(SpecInt32Only);
                 break;
             case Array::Double:
                 if (arrayMode.isOutOfBounds())
@@ -353,18 +353,18 @@ private:
                 break;
             case Array::Uint32Array:
                 if (isInt32SpeculationForArithmetic(node->getHeapPrediction()))
-                    changed |= mergePrediction(SpecInt32);
+                    changed |= mergePrediction(SpecInt32Only);
                 else if (enableInt52())
-                    changed |= mergePrediction(SpecMachineInt);
+                    changed |= mergePrediction(SpecAnyInt);
                 else
-                    changed |= mergePrediction(SpecInt32 | SpecInt52AsDouble);
+                    changed |= mergePrediction(SpecInt32Only | SpecAnyIntAsDouble);
                 break;
             case Array::Int8Array:
             case Array::Uint8Array:
             case Array::Int16Array:
             case Array::Uint16Array:
             case Array::Int32Array:
-                changed |= mergePrediction(SpecInt32);
+                changed |= mergePrediction(SpecInt32Only);
                 break;
             default:
                 changed |= mergePrediction(node->getHeapPrediction());
@@ -383,17 +383,17 @@ private:
                 }
 
                 if (node->child1()->shouldSpeculateInt32()) {
-                    changed |= mergePrediction(SpecInt32);
+                    changed |= mergePrediction(SpecInt32Only);
                     break;
                 }
 
-                if (enableInt52() && node->child1()->shouldSpeculateMachineInt()) {
-                    changed |= mergePrediction(SpecMachineInt);
+                if (enableInt52() && node->child1()->shouldSpeculateAnyInt()) {
+                    changed |= mergePrediction(SpecAnyInt);
                     break;
                 }
 
                 if (node->child1()->shouldSpeculateNumber()) {
-                    changed |= mergePrediction(SpecMachineInt);
+                    changed |= mergePrediction(SpecAnyInt);
                     break;
                 }
 
@@ -482,7 +482,7 @@ private:
             if (isFullNumberSpeculation(left)
                 && isFullNumberSpeculation(right)
                 && !m_graph.addShouldSpeculateInt32(node, m_pass)
-                && !m_graph.addShouldSpeculateMachineInt(node))
+                && !m_graph.addShouldSpeculateAnyInt(node))
                 ballot = VoteDouble;
             else
                 ballot = VoteValue;
@@ -501,7 +501,7 @@ private:
             if (isFullNumberSpeculation(left)
                 && isFullNumberSpeculation(right)
                 && !m_graph.binaryArithShouldSpeculateInt32(node, m_pass)
-                && !m_graph.binaryArithShouldSpeculateMachineInt(node, m_pass))
+                && !m_graph.binaryArithShouldSpeculateAnyInt(node, m_pass))
                 ballot = VoteDouble;
             else
                 ballot = VoteValue;
@@ -558,7 +558,7 @@ private:
             if (isDoubleSpeculation(prediction))
                 node->variableAccessData()->vote(VoteDouble, weight);
             else if (!isFullNumberSpeculation(prediction)
-                || isInt32Speculation(prediction) || isMachineIntSpeculation(prediction))
+                || isInt32Speculation(prediction) || isAnyIntSpeculation(prediction))
                 node->variableAccessData()->vote(VoteValue, weight);
             break;
         }
@@ -643,8 +643,8 @@ private:
         switch (m_currentNode->op()) {
         case JSConstant: {
             SpeculatedType type = speculationFromValue(m_currentNode->asJSValue());
-            if (type == SpecInt52AsDouble && enableInt52())
-                type = SpecInt52;
+            if (type == SpecAnyIntAsDouble && enableInt52())
+                type = SpecInt52Only;
             setPrediction(type);
             break;
         }
@@ -661,7 +661,7 @@ private:
         case BitURShift:
         case ArithIMul:
         case ArithClz32: {
-            setPrediction(SpecInt32);
+            setPrediction(SpecInt32Only);
             break;
         }
 
@@ -717,23 +717,23 @@ private:
         }
             
         case GetArgumentCount: {
-            setPrediction(SpecInt32);
+            setPrediction(SpecInt32Only);
             break;
         }
 
         case GetRestLength: {
-            setPrediction(SpecInt32);
+            setPrediction(SpecInt32Only);
             break;
         }
 
         case GetTypedArrayByteOffset:
         case GetArrayLength: {
-            setPrediction(SpecInt32);
+            setPrediction(SpecInt32Only);
             break;
         }
 
         case StringCharCodeAt: {
-            setPrediction(SpecInt32);
+            setPrediction(SpecInt32Only);
             break;
         }
         case ArithPow:
@@ -866,7 +866,7 @@ private:
             
         case FiatInt52: {
             RELEASE_ASSERT(enableInt52());
-            setPrediction(SpecMachineInt);
+            setPrediction(SpecAnyInt);
             break;
         }
 
@@ -879,7 +879,7 @@ private:
             break;
 
         case GetEnumerableLength: {
-            setPrediction(SpecInt32);
+            setPrediction(SpecInt32Only);
             break;
         }
         case HasGenericProperty:
index b53c16f..3214cff 100644 (file)
@@ -83,7 +83,7 @@ private:
             
             if (m_node->arrayMode().typedArrayType() != NotTypedArray && m_node->arrayMode().isOutOfBounds()) {
                 Node* length = m_insertionSet.insertNode(
-                    m_nodeIndex, SpecInt32, GetArrayLength, m_node->origin,
+                    m_nodeIndex, SpecInt32Only, GetArrayLength, m_node->origin,
                     OpInfo(m_node->arrayMode().asWord()), base, storage);
                 
                 m_graph.varArgChild(m_node, 4) = Edge(length, KnownInt32Use);
@@ -106,10 +106,10 @@ private:
             storage = Edge();
         
         Node* length = m_insertionSet.insertNode(
-            m_nodeIndex, SpecInt32, GetArrayLength, m_node->origin,
+            m_nodeIndex, SpecInt32Only, GetArrayLength, m_node->origin,
             OpInfo(m_node->arrayMode().asWord()), base, storage);
         m_insertionSet.insertNode(
-            m_nodeIndex, SpecInt32, CheckInBounds, m_node->origin,
+            m_nodeIndex, SpecInt32Only, CheckInBounds, m_node->origin,
             index, Edge(length, KnownInt32Use));
         return true;
     }
index a88ca5d..030e541 100644 (file)
@@ -69,12 +69,12 @@ public:
         case NotCellUse:
         case OtherUse:
         case MiscUse:
-        case MachineIntUse:
-        case DoubleRepMachineIntUse:
+        case AnyIntUse:
+        case DoubleRepAnyIntUse:
             return;
             
         case KnownInt32Use:
-            if (m_state.forNode(edge).m_type & ~SpecInt32)
+            if (m_state.forNode(edge).m_type & ~SpecInt32Only)
                 m_result = false;
             return;
 
index a3d0e56..935ba8a 100644 (file)
@@ -609,10 +609,10 @@ void SpeculativeJIT::silentFill(const SilentRegisterSavePlan& plan, GPRReg canTr
         break;
 #if USE(JSVALUE64)
     case SetInt52Constant:
-        m_jit.move(Imm64(plan.node()->asMachineInt() << JSValue::int52ShiftAmount), plan.gpr());
+        m_jit.move(Imm64(plan.node()->asAnyInt() << JSValue::int52ShiftAmount), plan.gpr());
         break;
     case SetStrictInt52Constant:
-        m_jit.move(Imm64(plan.node()->asMachineInt()), plan.gpr());
+        m_jit.move(Imm64(plan.node()->asAnyInt()), plan.gpr());
         break;
 #endif // USE(JSVALUE64)
     case SetBooleanConstant:
@@ -2636,7 +2636,7 @@ void SpeculativeJIT::compileGetByValOnIntTypedArray(Node* node, TypedArrayType t
     }
     
 #if USE(JSVALUE64)
-    if (node->shouldSpeculateMachineInt()) {
+    if (node->shouldSpeculateAnyInt()) {
         m_jit.zeroExtend32ToPtr(resultReg, resultReg);
         strictInt52Result(resultReg, node);
         return;
@@ -3561,8 +3561,8 @@ void SpeculativeJIT::compileArithAdd(Node* node)
 
         // Will we need an overflow check? If we can prove that neither input can be
         // Int52 then the overflow check will not be necessary.
-        if (!m_state.forNode(node->child1()).couldBeType(SpecInt52)
-            && !m_state.forNode(node->child2()).couldBeType(SpecInt52)) {
+        if (!m_state.forNode(node->child1()).couldBeType(SpecInt52Only)
+            && !m_state.forNode(node->child2()).couldBeType(SpecInt52Only)) {
             SpeculateWhicheverInt52Operand op1(this, node->child1());
             SpeculateWhicheverInt52Operand op2(this, node->child2(), op1);
             GPRTemporary result(this, Reuse, op1);
@@ -3753,8 +3753,8 @@ void SpeculativeJIT::compileArithSub(Node* node)
 
         // Will we need an overflow check? If we can prove that neither input can be
         // Int52 then the overflow check will not be necessary.
-        if (!m_state.forNode(node->child1()).couldBeType(SpecInt52)
-            && !m_state.forNode(node->child2()).couldBeType(SpecInt52)) {
+        if (!m_state.forNode(node->child1()).couldBeType(SpecInt52Only)
+            && !m_state.forNode(node->child2()).couldBeType(SpecInt52Only)) {
             SpeculateWhicheverInt52Operand op1(this, node->child1());
             SpeculateWhicheverInt52Operand op2(this, node->child2(), op1);
             GPRTemporary result(this, Reuse, op1);
@@ -3875,7 +3875,7 @@ void SpeculativeJIT::compileArithNegate(Node* node)
     case Int52RepUse: {
         ASSERT(shouldCheckOverflow(node->arithMode()));
         
-        if (!m_state.forNode(node->child1()).couldBeType(SpecInt52)) {
+        if (!m_state.forNode(node->child1()).couldBeType(SpecInt52Only)) {
             SpeculateWhicheverInt52Operand op1(this, node->child1());
             GPRTemporary result(this);
             GPRReg op1GPR = op1.gpr();
@@ -6900,7 +6900,7 @@ void SpeculativeJIT::speculateCellType(
 
 void SpeculativeJIT::speculateInt32(Edge edge)
 {
-    if (!needsTypeCheck(edge, SpecInt32))
+    if (!needsTypeCheck(edge, SpecInt32Only))
         return;
     
     (SpeculateInt32Operand(this, edge)).gpr();
@@ -6920,7 +6920,7 @@ void SpeculativeJIT::speculateNumber(Edge edge)
 #else
     GPRReg tagGPR = value.tagGPR();
     DFG_TYPE_CHECK(
-        value.jsValueRegs(), edge, ~SpecInt32,
+        value.jsValueRegs(), edge, ~SpecInt32Only,
         m_jit.branch32(MacroAssembler::Equal, tagGPR, TrustedImm32(JSValue::Int32Tag)));
     DFG_TYPE_CHECK(
         value.jsValueRegs(), edge, SpecBytecodeNumber,
@@ -7248,7 +7248,7 @@ void SpeculativeJIT::speculateMisc(Edge edge, JSValueRegs regs)
         m_jit.branch64(MacroAssembler::Above, regs.gpr(), MacroAssembler::TrustedImm64(TagBitTypeOther | TagBitBool | TagBitUndefined)));
 #else
     DFG_TYPE_CHECK(
-        regs, edge, ~SpecInt32,
+        regs, edge, ~SpecInt32Only,
         m_jit.branch32(MacroAssembler::Equal, regs.tagGPR(), MacroAssembler::TrustedImm32(JSValue::Int32Tag)));
     DFG_TYPE_CHECK(
         regs, edge, SpecMisc,
@@ -7271,13 +7271,13 @@ void SpeculativeJIT::speculate(Node*, Edge edge)
     case UntypedUse:
         break;
     case KnownInt32Use:
-        ASSERT(!needsTypeCheck(edge, SpecInt32));
+        ASSERT(!needsTypeCheck(edge, SpecInt32Only));
         break;
     case DoubleRepUse:
         ASSERT(!needsTypeCheck(edge, SpecFullDouble));
         break;
     case Int52RepUse:
-        ASSERT(!needsTypeCheck(edge, SpecMachineInt));
+        ASSERT(!needsTypeCheck(edge, SpecAnyInt));
         break;
     case KnownCellUse:
         ASSERT(!needsTypeCheck(edge, SpecCell));
@@ -7301,11 +7301,11 @@ void SpeculativeJIT::speculate(Node*, Edge edge)
         speculateDoubleRepReal(edge);
         break;
 #if USE(JSVALUE64)
-    case MachineIntUse:
-        speculateMachineInt(edge);
+    case AnyIntUse:
+        speculateAnyInt(edge);
         break;
-    case DoubleRepMachineIntUse:
-        speculateDoubleRepMachineInt(edge);
+    case DoubleRepAnyIntUse:
+        speculateDoubleRepAnyInt(edge);
         break;
 #endif
     case BooleanUse:
index 57c23f6..485563a 100644 (file)
@@ -564,10 +564,10 @@ public:
         }
     }
     
-    bool isKnownInteger(Node* node) { return m_state.forNode(node).isType(SpecInt32); }
+    bool isKnownInteger(Node* node) { return m_state.forNode(node).isType(SpecInt32Only); }
     bool isKnownCell(Node* node) { return m_state.forNode(node).isType(SpecCell); }
     
-    bool isKnownNotInteger(Node* node) { return !(m_state.forNode(node).m_type & SpecInt32); }
+    bool isKnownNotInteger(Node* node) { return !(m_state.forNode(node).m_type & SpecInt32Only); }
     bool isKnownNotNumber(Node* node) { return !(m_state.forNode(node).m_type & SpecFullNumber); }
     bool isKnownNotCell(Node* node) { return !(m_state.forNode(node).m_type & SpecCell); }
     bool isKnownNotOther(Node* node) { return !(m_state.forNode(node).m_type & SpecOther); }
@@ -2674,9 +2674,9 @@ public:
     
     void speculateInt32(Edge);
 #if USE(JSVALUE64)
-    void convertMachineInt(Edge, GPRReg resultGPR);
-    void speculateMachineInt(Edge);
-    void speculateDoubleRepMachineInt(Edge);
+    void convertAnyInt(Edge, GPRReg resultGPR);
+    void speculateAnyInt(Edge);
+    void speculateDoubleRepAnyInt(Edge);
 #endif // USE(JSVALUE64)
     void speculateNumber(Edge);
     void speculateRealNumber(Edge);
index 21f4207..fe8801b 100644 (file)
@@ -943,9 +943,9 @@ GPRReg SpeculativeJIT::fillSpeculateInt32Internal(Edge edge, DataFormat& returnF
 {
     AbstractValue& value = m_state.forNode(edge);
     SpeculatedType type = value.m_type;
-    ASSERT(edge.useKind() != KnownInt32Use || !(value.m_type & ~SpecInt32));
+    ASSERT(edge.useKind() != KnownInt32Use || !(value.m_type & ~SpecInt32Only));
 
-    m_interpreter.filter(value, SpecInt32);
+    m_interpreter.filter(value, SpecInt32Only);
     if (value.isClear()) {
         terminateSpeculativeExecution(Uncountable, JSValueRegs(), 0);
         returnFormat = DataFormatInt32;
@@ -972,7 +972,7 @@ GPRReg SpeculativeJIT::fillSpeculateInt32Internal(Edge edge, DataFormat& returnF
         ASSERT_UNUSED(spillFormat, (spillFormat & DataFormatJS) || spillFormat == DataFormatInt32);
 
         // If we know this was spilled as an integer we can fill without checking.
-        if (type & ~SpecInt32)
+        if (type & ~SpecInt32Only)
             speculationCheck(BadType, JSValueSource(JITCompiler::addressFor(virtualRegister)), edge, m_jit.branch32(MacroAssembler::NotEqual, JITCompiler::tagFor(virtualRegister), TrustedImm32(JSValue::Int32Tag)));
 
         GPRReg gpr = allocate();
@@ -990,7 +990,7 @@ GPRReg SpeculativeJIT::fillSpeculateInt32Internal(Edge edge, DataFormat& returnF
         GPRReg payloadGPR = info.payloadGPR();
         m_gprs.lock(tagGPR);
         m_gprs.lock(payloadGPR);
-        if (type & ~SpecInt32)
+        if (type & ~SpecInt32Only)
             speculationCheck(BadType, JSValueRegs(tagGPR, payloadGPR), edge, m_jit.branch32(MacroAssembler::NotEqual, tagGPR, TrustedImm32(JSValue::Int32Tag)));
         m_gprs.unlock(tagGPR);
         m_gprs.release(tagGPR);
@@ -1899,8 +1899,8 @@ void SpeculativeJIT::compile(Node* node)
             break;
         }
         case Int52RepUse: 
-        case MachineIntUse:
-        case DoubleRepMachineIntUse: {
+        case AnyIntUse:
+        case DoubleRepAnyIntUse: {
             RELEASE_ASSERT_NOT_REACHED();   
             break;
         }
index b52d47d..a75c75f 100644 (file)
@@ -901,9 +901,9 @@ GPRReg SpeculativeJIT::fillSpeculateInt32Internal(Edge edge, DataFormat& returnF
 {
     AbstractValue& value = m_state.forNode(edge);
     SpeculatedType type = value.m_type;
-    ASSERT(edge.useKind() != KnownInt32Use || !(value.m_type & ~SpecInt32));
+    ASSERT(edge.useKind() != KnownInt32Use || !(value.m_type & ~SpecInt32Only));
 
-    m_interpreter.filter(value, SpecInt32);
+    m_interpreter.filter(value, SpecInt32Only);
     if (value.isClear()) {
         terminateSpeculativeExecution(Uncountable, JSValueRegs(), 0);
         returnFormat = DataFormatInt32;
@@ -958,11 +958,11 @@ GPRReg SpeculativeJIT::fillSpeculateInt32Internal(Edge edge, DataFormat& returnF
     }
 
     case DataFormatJS: {
-        DFG_ASSERT(m_jit.graph(), m_currentNode, !(type & SpecInt52));
+        DFG_ASSERT(m_jit.graph(), m_currentNode, !(type & SpecInt52Only));
         // Check the value is an integer.
         GPRReg gpr = info.gpr();
         m_gprs.lock(gpr);
-        if (type & ~SpecInt32)
+        if (type & ~SpecInt32Only)
             speculationCheck(BadType, JSValueRegs(gpr), edge, m_jit.branch64(MacroAssembler::Below, gpr, GPRInfo::tagTypeNumberRegister));
         info.fillJSValue(*m_stream, gpr, DataFormatJSInt32);
         // If !strict we're done, return.
@@ -1045,7 +1045,7 @@ GPRReg SpeculativeJIT::fillSpeculateInt52(Edge edge, DataFormat desiredFormat)
     ASSERT(desiredFormat == DataFormatInt52 || desiredFormat == DataFormatStrictInt52);
     AbstractValue& value = m_state.forNode(edge);
 
-    m_interpreter.filter(value, SpecMachineInt);
+    m_interpreter.filter(value, SpecAnyInt);
     if (value.isClear()) {
         terminateSpeculativeExecution(Uncountable, JSValueRegs(), 0);
         return allocate();
@@ -1060,9 +1060,9 @@ GPRReg SpeculativeJIT::fillSpeculateInt52(Edge edge, DataFormat desiredFormat)
 
         if (edge->hasConstant()) {
             JSValue jsValue = edge->asJSValue();
-            ASSERT(jsValue.isMachineInt());
+            ASSERT(jsValue.isAnyInt());
             m_gprs.retain(gpr, virtualRegister, SpillOrderConstant);
-            int64_t value = jsValue.asMachineInt();
+            int64_t value = jsValue.asAnyInt();
             if (desiredFormat == DataFormatInt52)
                 value = value << JSValue::int52ShiftAmount;
             m_jit.move(MacroAssembler::Imm64(value), gpr);
@@ -1131,7 +1131,7 @@ GPRReg SpeculativeJIT::fillSpeculateInt52(Edge edge, DataFormat desiredFormat)
 
 FPRReg SpeculativeJIT::fillSpeculateDouble(Edge edge)
 {
-    ASSERT(edge.useKind() == DoubleRepUse || edge.useKind() == DoubleRepRealUse || edge.useKind() == DoubleRepMachineIntUse);
+    ASSERT(edge.useKind() == DoubleRepUse || edge.useKind() == DoubleRepRealUse || edge.useKind() == DoubleRepAnyIntUse);
     ASSERT(edge->hasDoubleResult());
     VirtualRegister virtualRegister = edge->virtualRegister();
     GenerationInfo& info = generationInfoFromVirtualRegister(virtualRegister);
@@ -1932,7 +1932,7 @@ void SpeculativeJIT::emitBranch(Node* node)
             GPRTemporary result(this);
             GPRReg resultGPR = result.gpr();
             
-            if (node->child1()->prediction() & SpecInt32) {
+            if (node->child1()->prediction() & SpecInt32Only) {
                 branch64(MacroAssembler::Equal, valueGPR, MacroAssembler::TrustedImm64(JSValue::encode(jsNumber(0))), notTaken);
                 branch64(MacroAssembler::AboveOrEqual, valueGPR, GPRInfo::tagTypeNumberRegister, taken);
             }
@@ -1987,7 +1987,7 @@ void SpeculativeJIT::compile(Node* node)
         switch (node->child1().useKind()) {
         case DoubleRepUse:
         case DoubleRepRealUse:
-        case DoubleRepMachineIntUse: {
+        case DoubleRepAnyIntUse: {
             SpeculateDoubleOperand op(this, node->child1());
             FPRTemporary scratch(this, op);
             m_jit.moveDouble(op.fpr(), scratch.fpr());
@@ -2222,17 +2222,17 @@ void SpeculativeJIT::compile(Node* node)
             break;
         }
             
-        case MachineIntUse: {
+        case AnyIntUse: {
             GPRTemporary result(this);
             GPRReg resultGPR = result.gpr();
             
-            convertMachineInt(node->child1(), resultGPR);
+            convertAnyInt(node->child1(), resultGPR);
             
             strictInt52Result(resultGPR, node);
             break;
         }
             
-        case DoubleRepMachineIntUse: {
+        case DoubleRepAnyIntUse: {
             SpeculateDoubleOperand value(this, node->child1());
             FPRReg valueFPR = value.fpr();
             
@@ -2244,7 +2244,7 @@ void SpeculativeJIT::compile(Node* node)
             callOperation(operationConvertDoubleToInt52, resultGPR, valueFPR);
             
             DFG_TYPE_CHECK_WITH_EXIT_KIND(Int52Overflow,
-                JSValueRegs(), node->child1(), SpecInt52AsDouble,
+                JSValueRegs(), node->child1(), SpecAnyIntAsDouble,
                 m_jit.branch64(
                     JITCompiler::Equal, resultGPR,
                     JITCompiler::TrustedImm64(JSValue::notInt52)));
@@ -2827,7 +2827,7 @@ void SpeculativeJIT::compile(Node* node)
             
             if (arrayMode.type() == Array::Int32) {
                 DFG_TYPE_CHECK(
-                    JSValueRegs(valueReg), child3, SpecInt32,
+                    JSValueRegs(valueReg), child3, SpecInt32Only,
                     m_jit.branch64(
                         MacroAssembler::Below, valueReg, GPRInfo::tagTypeNumberRegister));
             }
@@ -3219,7 +3219,7 @@ void SpeculativeJIT::compile(Node* node)
 
             if (node->arrayMode().type() == Array::Int32) {
                 DFG_TYPE_CHECK(
-                    JSValueRegs(valueGPR), node->child2(), SpecInt32,
+                    JSValueRegs(valueGPR), node->child2(), SpecInt32Only,
                     m_jit.branch64(
                         MacroAssembler::Below, valueGPR, GPRInfo::tagTypeNumberRegister));
             }
@@ -3599,7 +3599,7 @@ void SpeculativeJIT::compile(Node* node)
                     GPRReg opGPR = operand.gpr();
                     if (hasInt32(node->indexingType())) {
                         DFG_TYPE_CHECK(
-                            JSValueRegs(opGPR), use, SpecInt32,
+                            JSValueRegs(opGPR), use, SpecInt32Only,
                             m_jit.branch64(
                                 MacroAssembler::Below, opGPR, GPRInfo::tagTypeNumberRegister));
                     }
@@ -3665,7 +3665,7 @@ void SpeculativeJIT::compile(Node* node)
                 GPRReg opGPR = operand.gpr();
                 if (hasInt32(node->indexingType())) {
                     DFG_TYPE_CHECK(
-                        JSValueRegs(opGPR), use, SpecInt32,
+                        JSValueRegs(opGPR), use, SpecInt32Only,
                         m_jit.branch64(
                             MacroAssembler::Below, opGPR, GPRInfo::tagTypeNumberRegister));
                 }
@@ -4998,7 +4998,7 @@ void SpeculativeJIT::compile(Node* node)
             m_jit.move(valueGPR, scratch2GPR);
             m_jit.and64(TrustedImm32(~1), scratch2GPR);
             jumpToEnd.append(m_jit.branch64(MacroAssembler::Equal, scratch2GPR, MacroAssembler::TrustedImm64(ValueFalse)));
-        } else if (cachedTypeLocation->m_lastSeenType == TypeMachineInt)
+        } else if (cachedTypeLocation->m_lastSeenType == TypeAnyInt)
             jumpToEnd.append(m_jit.branch64(MacroAssembler::AboveOrEqual, valueGPR, GPRInfo::tagTypeNumberRegister));
         else if (cachedTypeLocation->m_lastSeenType == TypeNumber)
             jumpToEnd.append(m_jit.branchTest64(MacroAssembler::NonZero, valueGPR, GPRInfo::tagTypeNumberRegister));
@@ -5207,7 +5207,7 @@ void SpeculativeJIT::blessBoolean(GPRReg gpr)
     m_jit.or32(TrustedImm32(ValueFalse), gpr);
 }
 
-void SpeculativeJIT::convertMachineInt(Edge valueEdge, GPRReg resultGPR)
+void SpeculativeJIT::convertAnyInt(Edge valueEdge, GPRReg resultGPR)
 {
     JSValueOperand value(this, valueEdge, ManualOperandSpeculation);
     GPRReg valueGPR = value.gpr();
@@ -5224,25 +5224,25 @@ void SpeculativeJIT::convertMachineInt(Edge valueEdge, GPRReg resultGPR)
     silentFillAllRegisters(resultGPR);
 
     DFG_TYPE_CHECK(
-        JSValueRegs(valueGPR), valueEdge, SpecInt32 | SpecInt52AsDouble,
+        JSValueRegs(valueGPR), valueEdge, SpecInt32Only | SpecAnyIntAsDouble,
         m_jit.branch64(
             JITCompiler::Equal, resultGPR,
             JITCompiler::TrustedImm64(JSValue::notInt52)));
     done.link(&m_jit);
 }
 
-void SpeculativeJIT::speculateMachineInt(Edge edge)
+void SpeculativeJIT::speculateAnyInt(Edge edge)
 {
-    if (!needsTypeCheck(edge, SpecInt32 | SpecInt52AsDouble))
+    if (!needsTypeCheck(edge, SpecInt32Only | SpecAnyIntAsDouble))
         return;
     
     GPRTemporary temp(this);
-    convertMachineInt(edge, temp.gpr());
+    convertAnyInt(edge, temp.gpr());
 }
 
-void SpeculativeJIT::speculateDoubleRepMachineInt(Edge edge)
+void SpeculativeJIT::speculateDoubleRepAnyInt(Edge edge)
 {
-    if (!needsTypeCheck(edge, SpecInt52AsDouble))
+    if (!needsTypeCheck(edge, SpecAnyIntAsDouble))
         return;
     
     SpeculateDoubleOperand value(this, edge);
@@ -5256,7 +5256,7 @@ void SpeculativeJIT::speculateDoubleRepMachineInt(Edge edge)
     callOperation(operationConvertDoubleToInt52, resultGPR, valueFPR);
     
     DFG_TYPE_CHECK(
-        JSValueRegs(), edge, SpecInt52AsDouble,
+        JSValueRegs(), edge, SpecAnyIntAsDouble,
         m_jit.branch64(
             JITCompiler::Equal, resultGPR,
             JITCompiler::TrustedImm64(JSValue::notInt52)));
index 502a147..e7f9934 100644 (file)
@@ -49,8 +49,8 @@ void printInternal(PrintStream& out, UseKind useKind)
     case Int52RepUse:
         out.print("Int52Rep");
         return;
-    case MachineIntUse:
-        out.print("MachineInt");
+    case AnyIntUse:
+        out.print("AnyInt");
         return;
     case NumberUse:
         out.print("Number");
@@ -64,8 +64,8 @@ void printInternal(PrintStream& out, UseKind useKind)
     case DoubleRepRealUse:
         out.print("DoubleRepReal");
         return;
-    case DoubleRepMachineIntUse:
-        out.print("DoubleRepMachineInt");
+    case DoubleRepAnyIntUse:
+        out.print("DoubleRepAnyInt");
         return;
     case BooleanUse:
         out.print("Boolean");
index 41527f6..b2c62c5 100644 (file)
@@ -44,7 +44,7 @@ enum UseKind {
     UntypedUse, // UntypedUse must come first (value 0).
     Int32Use,
     KnownInt32Use,
-    MachineIntUse,
+    AnyIntUse,
     NumberUse,
     RealNumberUse,
     BooleanUse,
@@ -74,7 +74,7 @@ enum UseKind {
     //    in an FP register.
     DoubleRepUse,
     DoubleRepRealUse,
-    DoubleRepMachineIntUse,
+    DoubleRepAnyIntUse,
 
     // 3. The Int52 representation for an unboxed integer value that must be stored
     //    in a GP register.
@@ -90,11 +90,11 @@ inline SpeculatedType typeFilterFor(UseKind useKind)
         return SpecFullTop;
     case Int32Use:
     case KnownInt32Use:
-        return SpecInt32;
+        return SpecInt32Only;
     case Int52RepUse:
-        return SpecMachineInt;
-    case MachineIntUse:
-        return SpecInt32 | SpecInt52AsDouble;
+        return SpecAnyInt;
+    case AnyIntUse:
+        return SpecInt32Only | SpecAnyIntAsDouble;
     case NumberUse:
         return SpecBytecodeNumber;
     case RealNumberUse:
@@ -103,8 +103,8 @@ inline SpeculatedType typeFilterFor(UseKind useKind)
         return SpecFullDouble;
     case DoubleRepRealUse:
         return SpecDoubleReal;
-    case DoubleRepMachineIntUse:
-        return SpecInt52AsDouble;
+    case DoubleRepAnyIntUse:
+        return SpecAnyIntAsDouble;
     case BooleanUse:
     case KnownBooleanUse:
         return SpecBoolean;
@@ -184,8 +184,8 @@ inline bool isNumerical(UseKind kind)
     case Int52RepUse:
     case DoubleRepUse:
     case DoubleRepRealUse:
-    case MachineIntUse:
-    case DoubleRepMachineIntUse:
+    case AnyIntUse:
+    case DoubleRepAnyIntUse:
         return true;
     default:
         return false;
@@ -197,7 +197,7 @@ inline bool isDouble(UseKind kind)
     switch (kind) {
     case DoubleRepUse:
     case DoubleRepRealUse:
-    case DoubleRepMachineIntUse:
+    case DoubleRepAnyIntUse:
         return true;
     default:
         return false;
index 2b398eb..553ce0d 100644 (file)
@@ -694,7 +694,7 @@ private:
         if (m_graph.m_planStage < PlanStage::AfterFixup)
             return;
         
-        VALIDATE((node, edge), edge.useKind() == DoubleRepUse || edge.useKind() == DoubleRepRealUse || edge.useKind() == DoubleRepMachineIntUse);
+        VALIDATE((node, edge), edge.useKind() == DoubleRepUse || edge.useKind() == DoubleRepRealUse || edge.useKind() == DoubleRepAnyIntUse);
     }
 
     void checkOperand(
index bd1ba87..8fc4267 100644 (file)
@@ -156,8 +156,8 @@ bool VariableAccessData::makePredictionForDoubleFormat()
     SpeculatedType type = m_prediction;
     if (type & ~SpecBytecodeNumber)
         type |= SpecDoublePureNaN;
-    if (type & SpecMachineInt)
-        type |= SpecInt52AsDouble;
+    if (type & SpecAnyInt)
+        type |= SpecAnyIntAsDouble;
     return checkAndSet(m_prediction, type);
 }
 
@@ -180,8 +180,8 @@ bool VariableAccessData::couldRepresentInt52Impl()
         return false;
     
     // The argument-aware prediction -- which merges all of an (inlined or machine)
-    // argument's variable access datas' predictions -- must possibly be MachineInt.
-    return !(argumentAwarePrediction() & ~SpecMachineInt);
+    // argument's variable access datas' predictions -- must possibly be AnyInt.
+    return !(argumentAwarePrediction() & ~SpecAnyInt);
 }
 
 FlushFormat VariableAccessData::flushFormat()
index d710839..cd0ad28 100644 (file)
@@ -500,8 +500,8 @@ CapabilityLevel canCompile(Graph& graph)
                 case MiscUse:
                 case StringIdentUse:
                 case NotStringVarUse:
-                case MachineIntUse:
-                case DoubleRepMachineIntUse:
+                case AnyIntUse:
+                case DoubleRepAnyIntUse:
                     // These are OK.
                     break;
                 default:
index 385bb89..3f4d902 100644 (file)
@@ -1082,7 +1082,7 @@ private:
     
     void compileInt52Constant()
     {
-        int64_t value = m_node->asMachineInt();
+        int64_t value = m_node->asAnyInt();
         
         setInt52(m_out.constInt64(value << JSValue::int52ShiftAmount));
         setStrictInt52(m_out.constInt64(value));
@@ -1261,13 +1261,13 @@ private:
             setStrictInt52(m_out.signExt32To64(lowInt32(m_node->child1())));
             return;
             
-        case MachineIntUse:
+        case AnyIntUse:
             setStrictInt52(
                 jsValueToStrictInt52(
                     m_node->child1(), lowJSValue(m_node->child1(), ManualOperandSpeculation)));
             return;
             
-        case DoubleRepMachineIntUse:
+        case DoubleRepAnyIntUse:
             setStrictInt52(
                 doubleToStrictInt52(
                     m_node->child1(), lowDouble(m_node->child1())));
@@ -1538,8 +1538,8 @@ private:
         }
             
         case Int52RepUse: {
-            if (!abstractValue(m_node->child1()).couldBeType(SpecInt52)
-                && !abstractValue(m_node->child2()).couldBeType(SpecInt52)) {
+            if (!abstractValue(m_node->child1()).couldBeType(SpecInt52Only)
+                && !abstractValue(m_node->child2()).couldBeType(SpecInt52Only)) {
                 Int52Kind kind;
                 LValue left = lowWhicheverInt52(m_node->child1(), kind);
                 LValue right = lowInt52(m_node->child2(), kind);
@@ -2085,7 +2085,7 @@ private:
         }
             
         case Int52RepUse: {
-            if (!abstractValue(m_node->child1()).couldBeType(SpecInt52)) {
+            if (!abstractValue(m_node->child1()).couldBeType(SpecInt52Only)) {
                 Int52Kind kind;
                 LValue value = lowWhicheverInt52(m_node->child1(), kind);
                 LValue result = m_out.neg(value);
@@ -2858,7 +2858,7 @@ private:
                         return;
                     }
                     
-                    if (m_node->shouldSpeculateMachineInt()) {
+                    if (m_node->shouldSpeculateAnyInt()) {
                         setStrictInt52(m_out.zeroExt(result, m_out.int64));
                         return;
                     }
@@ -2999,7 +2999,7 @@ private:
                 LValue value = lowJSValue(child3, ManualOperandSpeculation);
                 
                 if (m_node->arrayMode().type() == Array::Int32)
-                    FTL_TYPE_CHECK(jsValueValue(value), child3, SpecInt32, isNotInt32(value));
+                    FTL_TYPE_CHECK(jsValueValue(value), child3, SpecInt32Only, isNotInt32(value));
                 
                 TypedPointer elementPointer = m_out.baseIndex(
                     m_node->arrayMode().type() == Array::Int32 ?
@@ -3249,7 +3249,7 @@ private:
                 value = lowJSValue(m_node->child2(), ManualOperandSpeculation);
                 if (m_node->arrayMode().type() == Array::Int32) {
                     FTL_TYPE_CHECK(
-                        jsValueValue(value), m_node->child2(), SpecInt32, isNotInt32(value));
+                        jsValueValue(value), m_node->child2(), SpecInt32Only, isNotInt32(value));
                 }
                 storeType = Output::Store64;
             } else {
@@ -9313,13 +9313,13 @@ private:
         if (isValid(value)) {
             LValue boxedResult = value.value();
             FTL_TYPE_CHECK(
-                jsValueValue(boxedResult), edge, SpecInt32, isNotInt32(boxedResult));
+                jsValueValue(boxedResult), edge, SpecInt32Only, isNotInt32(boxedResult));
             LValue result = unboxInt32(boxedResult);
             setInt32(edge.node(), result);
             return result;
         }
 
-        DFG_ASSERT(m_graph, m_node, !(provenType(edge) & SpecInt32));
+        DFG_ASSERT(m_graph, m_node, !(provenType(edge) & SpecInt32Only));
         terminate(Uncountable);
         return m_out.int32Zero;
     }
@@ -9568,7 +9568,7 @@ private:
     {
         LValue result = m_out.castToInt32(value);
         FTL_TYPE_CHECK(
-            noValue(), edge, SpecInt32,
+            noValue(), edge, SpecInt32Only,
             m_out.notEqual(m_out.signExt32To64(result), value));
         setInt32(edge.node(), result);
         return result;
@@ -9618,13 +9618,13 @@ private:
     
     LValue isInt32(LValue jsValue, SpeculatedType type = SpecFullTop)
     {
-        if (LValue proven = isProvenValue(type, SpecInt32))
+        if (LValue proven = isProvenValue(type, SpecInt32Only))
             return proven;
         return m_out.aboveOrEqual(jsValue, m_tagTypeNumber);
     }
     LValue isNotInt32(LValue jsValue, SpeculatedType type = SpecFullTop)
     {
-        if (LValue proven = isProvenValue(type, ~SpecInt32))
+        if (LValue proven = isProvenValue(type, ~SpecInt32Only))
             return proven;
         return m_out.below(jsValue, m_tagTypeNumber);
     }
@@ -9666,9 +9666,9 @@ private:
         LBasicBlock continuation = m_out.newBlock();
             
         LValue isNotInt32;
-        if (!m_interpreter.needsTypeCheck(edge, SpecInt32))
+        if (!m_interpreter.needsTypeCheck(edge, SpecInt32Only))
             isNotInt32 = m_out.booleanFalse;
-        else if (!m_interpreter.needsTypeCheck(edge, ~SpecInt32))
+        else if (!m_interpreter.needsTypeCheck(edge, ~SpecInt32Only))
             isNotInt32 = m_out.booleanTrue;
         else
             isNotInt32 = this->isNotInt32(boxedValue);
@@ -9685,7 +9685,7 @@ private:
         LValue possibleResult = m_out.call(
             m_out.int64, m_out.operation(operationConvertBoxedDoubleToInt52), boxedValue);
         FTL_TYPE_CHECK(
-            jsValueValue(boxedValue), edge, SpecInt32 | SpecInt52AsDouble,
+            jsValueValue(boxedValue), edge, SpecInt32Only | SpecAnyIntAsDouble,
             m_out.equal(possibleResult, m_out.constInt64(JSValue::notInt52)));
             
         ValueFromBlock doubleToInt52 = m_out.anchor(possibleResult);
@@ -9701,7 +9701,7 @@ private:
         LValue possibleResult = m_out.call(
             m_out.int64, m_out.operation(operationConvertDoubleToInt52), value);
         FTL_TYPE_CHECK_WITH_EXIT_KIND(Int52Overflow,
-            doubleValue(value), edge, SpecInt52AsDouble,
+            doubleValue(value), edge, SpecAnyIntAsDouble,
             m_out.equal(possibleResult, m_out.constInt64(JSValue::notInt52)));
         
         return possibleResult;
@@ -9848,8 +9848,8 @@ private:
         case KnownCellUse:
             ASSERT(!m_interpreter.needsTypeCheck(edge));
             break;
-        case MachineIntUse:
-            speculateMachineInt(edge);
+        case AnyIntUse:
+            speculateAnyInt(edge);
             break;
         case ObjectUse:
             speculateObject(edge);
@@ -9893,8 +9893,8 @@ private:
         case DoubleRepRealUse:
             speculateDoubleRepReal(edge);
             break;
-        case DoubleRepMachineIntUse:
-            speculateDoubleRepMachineInt(edge);
+        case DoubleRepAnyIntUse:
+            speculateDoubleRepAnyInt(edge);
             break;
         case BooleanUse:
             speculateBoolean(edge);
@@ -9947,7 +9947,7 @@ private:
         m_out.appendTo(continuation, lastNext);
     }
     
-    void speculateMachineInt(Edge edge)
+    void speculateAnyInt(Edge edge)
     {
         if (!m_interpreter.needsTypeCheck(edge))
             return;
@@ -10345,7 +10345,7 @@ private:
             m_out.doubleNotEqualOrUnordered(value, value));
     }
     
-    void speculateDoubleRepMachineInt(Edge edge)
+    void speculateDoubleRepAnyInt(Edge edge)
     {
         if (!m_interpreter.needsTypeCheck(edge))
             return;
index f1364ff..dd8219c 100644 (file)
@@ -1297,7 +1297,7 @@ void JIT::emit_op_profile_type(Instruction* currentInstruction)
         move(regT0, regT1);
         and64(TrustedImm32(~1), regT1);
         jumpToEnd.append(branch64(Equal, regT1, TrustedImm64(ValueFalse)));
-    } else if (cachedTypeLocation->m_lastSeenType == TypeMachineInt)
+    } else if (cachedTypeLocation->m_lastSeenType == TypeAnyInt)
         jumpToEnd.append(emitJumpIfInt(regT0));
     else if (cachedTypeLocation->m_lastSeenType == TypeNumber)
         jumpToEnd.append(emitJumpIfNumber(regT0));
index ed44349..cc4b8f8 100644 (file)
@@ -1298,7 +1298,7 @@ void JIT::emit_op_profile_type(Instruction* currentInstruction)
         jumpToEnd.append(branch32(Equal, regT3, TrustedImm32(JSValue::NullTag)));
     else if (cachedTypeLocation->m_lastSeenType == TypeBoolean)
         jumpToEnd.append(branch32(Equal, regT3, TrustedImm32(JSValue::BooleanTag)));
-    else if (cachedTypeLocation->m_lastSeenType == TypeMachineInt)
+    else if (cachedTypeLocation->m_lastSeenType == TypeAnyInt)
         jumpToEnd.append(branch32(Equal, regT3, TrustedImm32(JSValue::Int32Tag)));
     else if (cachedTypeLocation->m_lastSeenType == TypeNumber) {
         jumpToEnd.append(branch32(Below, regT3, TrustedImm32(JSValue::LowestTag)));
index 0ab3084..90aae10 100644 (file)
@@ -214,7 +214,7 @@ public:
 
     int32_t asInt32() const;
     uint32_t asUInt32() const;
-    int64_t asMachineInt() const;
+    int64_t asAnyInt() const;
     double asDouble() const;
     bool asBoolean() const;
     double asNumber() const;
@@ -232,7 +232,7 @@ public:
     bool isNull() const;
     bool isUndefinedOrNull() const;
     bool isBoolean() const;
-    bool isMachineInt() const;
+    bool isAnyInt() const;
     bool isNumber() const;
     bool isString() const;
     bool isSymbol() const;
index 9905089..bedc622 100644 (file)
@@ -530,7 +530,7 @@ inline bool isInt52(double number)
     return tryConvertToInt52(number) != JSValue::notInt52;
 }
 
-inline bool JSValue::isMachineInt() const
+inline bool JSValue::isAnyInt() const
 {
     if (isInt32())
         return true;
@@ -539,9 +539,9 @@ inline bool JSValue::isMachineInt() const
     return isInt52(asDouble());
 }
 
-inline int64_t JSValue::asMachineInt() const
+inline int64_t JSValue::asAnyInt() const
 {
-    ASSERT(isMachineInt());
+    ASSERT(isAnyInt());
     if (isInt32())
         return asInt32();
     return static_cast<int64_t>(asDouble());
index ac9fe85..6ef504b 100644 (file)
@@ -42,8 +42,8 @@ RuntimeType runtimeTypeForValue(JSValue value)
         return TypeUndefined;
     if (value.isNull())
         return TypeNull;
-    if (value.isMachineInt())
-        return TypeMachineInt;
+    if (value.isAnyInt())
+        return TypeAnyInt;
     if (value.isNumber())
         return TypeNumber;
     if (value.isString())
@@ -66,7 +66,7 @@ String runtimeTypeAsString(RuntimeType type)
         return ASCIILiteral("Undefined");
     if (type == TypeNull)
         return ASCIILiteral("Null");
-    if (type == TypeMachineInt)
+    if (type == TypeAnyInt)
         return ASCIILiteral("Integer");
     if (type == TypeNumber)
         return ASCIILiteral("Number");
index 3b216ed..7ab1f21 100644 (file)
@@ -37,7 +37,7 @@ enum RuntimeType : uint16_t {
     TypeUndefined          = 0x2,
     TypeNull               = 0x4,
     TypeBoolean            = 0x8,
-    TypeMachineInt         = 0x10,
+    TypeAnyInt             = 0x10,
     TypeNumber             = 0x20,
     TypeString             = 0x40,
     TypeObject             = 0x80,
@@ -46,7 +46,7 @@ enum RuntimeType : uint16_t {
 
 typedef uint16_t RuntimeTypeMask;
 
-static const RuntimeTypeMask RuntimeTypeMaskAllTypes = TypeFunction | TypeUndefined | TypeNull | TypeBoolean | TypeMachineInt | TypeNumber | TypeString | TypeObject | TypeSymbol;
+static const RuntimeTypeMask RuntimeTypeMaskAllTypes = TypeFunction | TypeUndefined | TypeNull | TypeBoolean | TypeAnyInt | TypeNumber | TypeString | TypeObject | TypeSymbol;
 
 class JSValue;
 RuntimeType runtimeTypeForValue(JSValue);
index a5ec952..3867127 100644 (file)
@@ -100,8 +100,8 @@ String TypeSet::dumpTypes() const
         seen.appendLiteral("Null ");
     if (m_seenTypes & TypeBoolean)
         seen.appendLiteral("Boolean ");
-    if (m_seenTypes & TypeMachineInt)
-        seen.appendLiteral("MachineInt ");
+    if (m_seenTypes & TypeAnyInt)
+        seen.appendLiteral("AnyInt ");
     if (m_seenTypes & TypeNumber)
         seen.appendLiteral("Number ");
     if (m_seenTypes & TypeString)
@@ -179,9 +179,9 @@ String TypeSet::displayName() const
         return ASCIILiteral("Null");
     if (doesTypeConformTo(TypeBoolean))
         return ASCIILiteral("Boolean");
-    if (doesTypeConformTo(TypeMachineInt))
+    if (doesTypeConformTo(TypeAnyInt))
         return ASCIILiteral("Integer");
-    if (doesTypeConformTo(TypeNumber | TypeMachineInt))
+    if (doesTypeConformTo(TypeNumber | TypeAnyInt))
         return ASCIILiteral("Number");
     if (doesTypeConformTo(TypeString))
         return ASCIILiteral("String");
@@ -195,9 +195,9 @@ String TypeSet::displayName() const
         return ASCIILiteral("Function?");
     if (doesTypeConformTo(TypeBoolean | TypeNull | TypeUndefined))
         return ASCIILiteral("Boolean?");
-    if (doesTypeConformTo(TypeMachineInt | TypeNull | TypeUndefined))
+    if (doesTypeConformTo(TypeAnyInt | TypeNull | TypeUndefined))
         return ASCIILiteral("Integer?");
-    if (doesTypeConformTo(TypeNumber | TypeMachineInt | TypeNull | TypeUndefined))
+    if (doesTypeConformTo(TypeNumber | TypeAnyInt | TypeNull | TypeUndefined))
         return ASCIILiteral("Number?");
     if (doesTypeConformTo(TypeString | TypeNull | TypeUndefined))
         return ASCIILiteral("String?");
@@ -234,7 +234,7 @@ Ref<Inspector::Protocol::Runtime::TypeSet> TypeSet::inspectorTypeSet() const
         .setIsUndefined((m_seenTypes & TypeUndefined) != TypeNothing)
         .setIsNull((m_seenTypes & TypeNull) != TypeNothing)
         .setIsBoolean((m_seenTypes & TypeBoolean) != TypeNothing)
-        .setIsInteger((m_seenTypes & TypeMachineInt) != TypeNothing)
+        .setIsInteger((m_seenTypes & TypeAnyInt) != TypeNothing)
         .setIsNumber((m_seenTypes & TypeNumber) != TypeNothing)
         .setIsString((m_seenTypes & TypeString) != TypeNothing)
         .setIsObject((m_seenTypes & TypeObject) != TypeNothing)
@@ -277,7 +277,7 @@ String TypeSet::toJSONString() const
         hasAnItem = true;
         json.appendLiteral("\"Boolean\"");
     }
-    if (m_seenTypes & TypeMachineInt) {
+    if (m_seenTypes & TypeAnyInt) {
         if (hasAnItem)
             json.append(',');
         hasAnItem = true;