Changeset 200034 in webkit

Timestamp:

Apr 25, 2016, 10:48:46 AM (9 years ago)

Author:

mark.lam@apple.com

Message:

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):

Location:

trunk/Source/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• bindings/ScriptValue.cpp (modified) (1 diff)
• bytecode/SpeculatedType.cpp (modified) (8 diffs)
• bytecode/SpeculatedType.h (modified) (4 diffs)
• dfg/DFGAbstractInterpreterInlines.h (modified) (28 diffs)
• dfg/DFGAbstractValue.cpp (modified) (4 diffs)
• dfg/DFGAbstractValue.h (modified) (2 diffs)
• dfg/DFGArgumentsUtilities.cpp (modified) (1 diff)
• dfg/DFGByteCodeParser.cpp (modified) (2 diffs)
• dfg/DFGFixupPhase.cpp (modified) (21 diffs)
• dfg/DFGGraph.h (modified) (5 diffs)
• dfg/DFGInPlaceAbstractState.cpp (modified) (1 diff)
• dfg/DFGJITCompiler.cpp (modified) (1 diff)
• dfg/DFGNode.cpp (modified) (1 diff)
• dfg/DFGNode.h (modified) (3 diffs)
• dfg/DFGOSREntry.cpp (modified) (3 diffs)
• dfg/DFGOSREntry.h (modified) (1 diff)
• dfg/DFGPredictionPropagationPhase.cpp (modified) (25 diffs)
• dfg/DFGSSALoweringPhase.cpp (modified) (2 diffs)
• dfg/DFGSafeToExecute.h (modified) (1 diff)
• dfg/DFGSpeculativeJIT.cpp (modified) (11 diffs)
• dfg/DFGSpeculativeJIT.h (modified) (2 diffs)
• dfg/DFGSpeculativeJIT32_64.cpp (modified) (4 diffs)
• dfg/DFGSpeculativeJIT64.cpp (modified) (19 diffs)
• dfg/DFGUseKind.cpp (modified) (2 diffs)
• dfg/DFGUseKind.h (modified) (6 diffs)
• dfg/DFGValidate.cpp (modified) (1 diff)
• dfg/DFGVariableAccessData.cpp (modified) (2 diffs)
• ftl/FTLCapabilities.cpp (modified) (1 diff)
• ftl/FTLLowerDFGToB3.cpp (modified) (20 diffs)
• jit/JITOpcodes.cpp (modified) (1 diff)
• jit/JITOpcodes32_64.cpp (modified) (1 diff)
• runtime/JSCJSValue.h (modified) (2 diffs)
• runtime/JSCJSValueInlines.h (modified) (2 diffs)
• runtime/RuntimeType.cpp (modified) (2 diffs)
• runtime/RuntimeType.h (modified) (2 diffs)
• runtime/TypeSet.cpp (modified) (5 diffs)

trunk/Source/JavaScriptCore/ChangeLog ¶

@@ +1 @@
+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>
 

trunk/Source/JavaScriptCore/bindings/ScriptValue.cpp ¶

@@ -59 +59 @@
     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));

trunk/Source/JavaScriptCore/bytecode/SpeculatedType.cpp ¶

@@ -169 +169 @@
     }
     
-    if (value == SpecInt32)
+    if (value == SpecInt32Only)
         myOut.print("Int32");
     else {
@@ -183 +183 @@
     }
     
-    if (value & SpecInt52)
+    if (value & SpecInt52Only)
         myOut.print("Int52");
         
@@ -189 +189 @@
         myOut.print("Bytecodedouble");
     else {
-        if (value & SpecInt52AsDouble)
-            myOut.print("Int52asdouble");
+        if (value & SpecAnyIntAsDouble)
+            myOut.print("AnyIntAsDouble");
         else
             isTop = false;
@@ -275 +275 @@
     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>";
@@ -394 +394 @@
         if (number != number)
             return SpecDoublePureNaN;
-        if (value.isMachineInt())
-            return SpecInt52AsDouble;
+        if (value.isAnyInt())
+            return SpecAnyIntAsDouble;
         return SpecNonIntAsDouble;
     }
@@ -440 +440 @@
 SpeculatedType leastUpperBoundOfStrictlyEquivalentSpeculations(SpeculatedType type)
 {
-    if (type & SpecInteger)
-        type |= SpecInteger;
+    if (type & (SpecAnyInt | SpecAnyIntAsDouble))
+        type |= (SpecAnyInt | SpecAnyIntAsDouble);
     if (type & SpecString)
         type |= SpecString;
@@ -527 +527 @@
     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.
@@ -548 +548 @@
     // We might lose bits, which leads to a value becoming integer-representable.
     if (value & SpecNonIntAsDouble)
-        value |= SpecInt52AsDouble;
+        value |= SpecAnyIntAsDouble;
     return value;
 }

trunk/Source/JavaScriptCore/bytecode/SpeculatedType.h ¶

@@ -67 +67 @@
 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).
@@ -79 +78 @@
 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.
 
@@ -289 +288 @@
 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));
 }
 
@@ -314 +313 @@
 inline bool isInt52Speculation(SpeculatedType value)
 {
-    return value == SpecInt52;
-}
-
-inline bool isMachineIntSpeculation(SpeculatedType value)
-{
-    return !!value && (value & SpecMachineInt) == value;
-}
-
-inline bool isInt52AsDoubleSpeculation(SpeculatedType value)
-{
-    return value == SpecInt52AsDouble;
-}
-
-inline bool isIntegerSpeculation(SpeculatedType value)
-{
-    return !!value && (value & SpecInteger) == value;
+    return value == SpecInt52Only;
+}
+
+inline bool isAnyIntSpeculation(SpeculatedType value)
+{
+    return !!value && (value & SpecAnyInt) == value;
+}
+
+inline bool isAnyIntAsDoubleSpeculation(SpeculatedType value)
+{
+    return value == SpecAnyIntAsDouble;
 }
 

trunk/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h ¶

@@ -238 +238 @@
         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();
@@ -252 +252 @@
         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;
         }
@@ -294 +294 @@
         }
         
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }
@@ -302 +302 @@
         if (doesOverflow(node->arithMode())) {
             if (enableInt52()) {
-                if (child && child.isMachineInt()) {
-                    setConstant(node, jsNumber(child.asMachineInt()));
-                    break;
-                }
-                forNode(node).setType(SpecMachineInt);
+                if (child && child.isAnyInt()) {
+                    setConstant(node, jsNumber(child.asAnyInt()));
+                    break;
+                }
+                forNode(node).setType(SpecAnyInt);
                 break;
             }
@@ -314 +314 @@
                 break;
             }
-            forNode(node).setType(SpecInt52AsDouble);
+            forNode(node).setType(SpecAnyIntAsDouble);
             break;
         }
@@ -324 +324 @@
             }
         }
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }
@@ -358 +358 @@
             }
         }
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }
@@ -387 +387 @@
         }
         
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }
@@ -442 +442 @@
     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;
     }
@@ -491 +491 @@
                 }
             }
-            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:
@@ -526 +526 @@
             break;
         }
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }
@@ -551 +551 @@
                 }
             }
-            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:
@@ -603 +603 @@
                 }
             }
-            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()))
@@ -613 +613 @@
                     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:
@@ -655 +655 @@
                 }
             }
-            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:
@@ -707 +707 @@
                 }
             }
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case DoubleRepUse:
@@ -746 +746 @@
                 }
             }
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case DoubleRepUse:
@@ -773 +773 @@
                 break;
             }
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case DoubleRepUse:
@@ -802 +802 @@
                 break;
             }
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case DoubleRepUse:
@@ -833 +833 @@
                 }
             }
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
             break;
         case DoubleRepUse:
@@ -909 +909 @@
         }
         if (producesInteger(node->arithRoundingMode()))
-            forNode(node).setType(SpecInt32);
+            forNode(node).setType(SpecInt32Only);
         else
             forNode(node).setType(typeOfDoubleRounding(forNode(node->child1()).m_type));
@@ -1463 +1463 @@
         
     case StringCharCodeAt:
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
         
@@ -1523 +1523 @@
                 forNode(node).makeHeapTop();
             } else
-                forNode(node).setType(SpecInt32);
+                forNode(node).setType(SpecInt32Only);
             break;
         case Array::Double:
@@ -1542 +1542 @@
             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:
@@ -1968 +1968 @@
         
     case GetArgumentCount:
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
         
     case GetRestLength:
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
         
@@ -2125 +2125 @@
             break;
         }
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }
@@ -2351 +2351 @@
             break;
         }
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }
@@ -2633 +2633 @@
             
     case GetEnumerableLength: {
-        forNode(node).setType(SpecInt32);
+        forNode(node).setType(SpecInt32Only);
         break;
     }

trunk/Source/JavaScriptCore/dfg/DFGAbstractValue.cpp ¶

@@ -131 +131 @@
         return;
     case InferredType::Int32:
-        setType(SpecInt32);
+        setType(SpecInt32Only);
         return;
     case InferredType::Number:
@@ -179 +179 @@
                 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 & ~SpecMachineInt)
-            DFG_CRASH(graph, node, toCString("Abstract value ", *this, " for int52 node has type outside SpecMachineInt.\n").data());
+        if (m_type & SpecAnyIntAsDouble) {
+            m_type &= ~SpecAnyIntAsDouble;
+            m_type |= SpecInt52Only;
+        }
+        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)
@@ -481 +481 @@
         // 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);
     }
@@ -503 +503 @@
     if (isType(SpecBoolean))
         return ResultType::booleanType();
-    if (isType(SpecInt32))
+    if (isType(SpecInt32Only))
         return ResultType::numberTypeIsInt32();
     if (isType(SpecBytecodeNumber))

trunk/Source/JavaScriptCore/dfg/DFGAbstractValue.h ¶

@@ -377 +377 @@
     // 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.
@@ -420 +420 @@
             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)

trunk/Source/JavaScriptCore/dfg/DFGArgumentsUtilities.cpp ¶

@@ -77 +77 @@
     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(

trunk/Source/JavaScriptCore/dfg/DFGByteCodeParser.cpp ¶

@@ -1745 +1745 @@
                     // 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));
@@ -2347 +2347 @@
             Node* node = get(virtualRegisterForArgument(i, registerOffset));
             if (node->hasHeapPrediction())
-                node->setHeapPrediction(SpecInt32);
+                node->setHeapPrediction(SpecInt32Only);
         }
         set(VirtualRegister(resultOperand), addToGraph(JSConstant, OpInfo(m_constantUndefined)));

trunk/Source/JavaScriptCore/dfg/DFGFixupPhase.cpp ¶

@@ -220 +220 @@
                 break;
             }
-            if (m_graph.unaryArithShouldSpeculateMachineInt(node, FixupPass)) {
+            if (m_graph.unaryArithShouldSpeculateAnyInt(node, FixupPass)) {
                 fixEdge<Int52RepUse>(node->child1());
                 if (bytecodeCanIgnoreNegativeZero(node->arithNodeFlags()))
@@ -256 +256 @@
                 break;
             }
-            if (m_graph.binaryArithShouldSpeculateMachineInt(node, FixupPass)) {
+            if (m_graph.binaryArithShouldSpeculateAnyInt(node, FixupPass)) {
                 fixEdge<Int52RepUse>(leftChild);
                 fixEdge<Int52RepUse>(rightChild);
@@ -447 +447 @@
             }
             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());
@@ -552 +552 @@
             }
             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());
@@ -764 +764 @@
                 if (node->shouldSpeculateInt32())
                     break;
-                if (node->shouldSpeculateMachineInt() && enableInt52())
+                if (node->shouldSpeculateAnyInt() && enableInt52())
                     node->setResult(NodeResultInt52);
                 else
@@ -830 +830 @@
                 if (child3->shouldSpeculateInt32())
                     fixIntOrBooleanEdge(child3);
-                else if (child3->shouldSpeculateMachineInt())
+                else if (child3->shouldSpeculateAnyInt())
                     fixEdge<Int52RepUse>(child3);
                 else
@@ -870 +870 @@
                     m_graph, node,
                     node->child1()->prediction() & SpecCell,
-                    SpecInt32,
+                    SpecInt32Only,
                     node->child2()->prediction()));
             blessArrayOperation(node->child1(), Edge(), node->child3());
@@ -1434 +1434 @@
             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();
@@ -1679 +1679 @@
             }
 
-            if (enableInt52() && node->child1()->shouldSpeculateMachineInt()) {
+            if (enableInt52() && node->child1()->shouldSpeculateAnyInt()) {
                 fixEdge<Int52RepUse>(node->child1());
                 node->convertToIdentity();
@@ -2033 +2033 @@
             break;
         case Int52RepUse:
-            if (isMachineIntSpeculation(variable->prediction()))
+            if (isAnyIntSpeculation(variable->prediction()))
                 m_profitabilityChanged |= variable->mergeIsProfitableToUnbox(true);
             break;
@@ -2110 +2110 @@
         
         UseKind useKind;
-        if (node->shouldSpeculateMachineInt())
+        if (node->shouldSpeculateAnyInt())
             useKind = Int52RepUse;
         else if (node->shouldSpeculateNumber())
@@ -2117 +2117 @@
             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);
@@ -2138 +2138 @@
             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);
@@ -2159 +2159 @@
             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);
@@ -2177 +2177 @@
         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))));
     }
@@ -2207 +2207 @@
         }
         
-        if (m_graph.addShouldSpeculateMachineInt(node)) {
+        if (m_graph.addShouldSpeculateAnyInt(node)) {
             fixEdge<Int52RepUse>(node->child1());
             fixEdge<Int52RepUse>(node->child2());
@@ -2280 +2280 @@
         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));
     }
@@ -2370 +2370 @@
                     case DoubleRepUse:
                     case DoubleRepRealUse:
-                    case DoubleRepMachineIntUse: {
+                    case DoubleRepAnyIntUse: {
                         if (edge->hasDoubleResult())
                             break;
@@ -2380 +2380 @@
                         } else if (edge->hasInt52Result()) {
                             result = m_insertionSet.insertNode(
-                                indexForChecks, SpecInt52AsDouble, DoubleRep, originForChecks,
+                                indexForChecks, SpecAnyIntAsDouble, DoubleRep, originForChecks,
                                 Edge(edge.node(), Int52RepUse));
                         } else {
@@ -2404 +2404 @@
                             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));
                         }
 
@@ -2436 +2436 @@
                         } else {
                             result = m_insertionSet.insertNode(
-                                indexForChecks, SpecInt32 | SpecInt52AsDouble, ValueRep,
+                                indexForChecks, SpecInt32Only | SpecAnyIntAsDouble, ValueRep,
                                 originForChecks, Edge(edge.node(), Int52RepUse));
                         }

trunk/Source/JavaScriptCore/dfg/DFGGraph.h ¶

@@ -264 +264 @@
     }
     
-    bool addShouldSpeculateMachineInt(Node* add)
+    bool addShouldSpeculateAnyInt(Node* add)
     {
         if (!enableInt52())
@@ -272 +272 @@
         Node* right = add->child2().node();
 
-        bool speculation = Node::shouldSpeculateMachineInt(left, right);
+        bool speculation = Node::shouldSpeculateAnyInt(left, right);
         return speculation && !hasExitSite(add, Int52Overflow);
     }
@@ -285 +285 @@
     }
     
-    bool binaryArithShouldSpeculateMachineInt(Node* node, PredictionPass pass)
+    bool binaryArithShouldSpeculateAnyInt(Node* node, PredictionPass pass)
     {
         if (!enableInt52())
@@ -293 +293 @@
         Node* right = node->child2().node();
 
-        return Node::shouldSpeculateMachineInt(left, right)
+        return Node::shouldSpeculateAnyInt(left, right)
             && node->canSpeculateInt52(pass)
             && !hasExitSite(node, Int52Overflow);
@@ -304 +304 @@
     }
     
-    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);

trunk/Source/JavaScriptCore/dfg/DFGInPlaceAbstractState.cpp ¶

@@ -119 +119 @@
         switch (format) {
         case FlushedInt32:
-            root->valuesAtHead.argument(i).setType(SpecInt32);
+            root->valuesAtHead.argument(i).setType(SpecInt32Only);
             break;
         case FlushedBoolean:

trunk/Source/JavaScriptCore/dfg/DFGJITCompiler.cpp ¶

@@ -543 +543 @@
                 break;
             case FlushedInt52:
-                entry->m_localsForcedMachineInt.set(local);
+                entry->m_localsForcedAnyInt.set(local);
                 break;
             default:

trunk/Source/JavaScriptCore/dfg/DFGNode.cpp ¶

@@ -133 +133 @@
         switch (input) {
         case NodeResultDouble:
-            child1().setUseKind(DoubleRepMachineIntUse);
+            child1().setUseKind(DoubleRepAnyIntUse);
             return;
         case NodeResultJS:
-            child1().setUseKind(MachineIntUse);
+            child1().setUseKind(AnyIntUse);
             return;
         default:

trunk/Source/JavaScriptCore/dfg/DFGNode.h ¶

@@ -682 +682 @@
     }
      
-    bool isMachineIntConstant()
-    {
-        return isConstant() && constant()->value().isMachineInt();
+    bool isAnyIntConstant()
+    {
+        return isConstant() && constant()->value().isAnyInt();
     }
      
-    int64_t asMachineInt()
-    {
-        return asJSValue().asMachineInt();
+    int64_t asAnyInt()
+    {
+        return asJSValue().asAnyInt();
     }
      
@@ -1921 +1921 @@
     }
     
-    bool shouldSpeculateMachineInt()
-    {
-        return isMachineIntSpeculation(prediction());
+    bool shouldSpeculateAnyInt()
+    {
+        return isAnyIntSpeculation(prediction());
     }
     
@@ -2154 +2154 @@
     }
     
-    static bool shouldSpeculateMachineInt(Node* op1, Node* op2)
-    {
-        return op1->shouldSpeculateMachineInt() && op2->shouldSpeculateMachineInt();
+    static bool shouldSpeculateAnyInt(Node* op1, Node* op2)
+    {
+        return op1->shouldSpeculateAnyInt() && op2->shouldSpeculateAnyInt();
     }
     

trunk/Source/JavaScriptCore/dfg/DFGOSREntry.cpp ¶

@@ -68 +68 @@
         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(")");
@@ -214 +214 @@
             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(
@@ -286 +286 @@
             }
             
-            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;
             }

trunk/Source/JavaScriptCore/dfg/DFGOSREntry.h ¶

@@ -58 +58 @@
     // 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;

trunk/Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp ¶

@@ -156 +156 @@
             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);
@@ -171 +171 @@
         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);
@@ -187 +187 @@
                     && 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));
@@ -198 +198 @@
                     changed |= mergePrediction(SpecString);
                 } else
-                    changed |= mergePrediction(SpecString | SpecInt32 | SpecBytecodeDouble);
+                    changed |= mergePrediction(SpecString | SpecInt32Only | SpecBytecodeDouble);
             }
             break;
@@ -209 +209 @@
             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));
@@ -226 +226 @@
                     && 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;
@@ -240 +240 @@
             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()));
@@ -256 +256 @@
                 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));
@@ -271 +271 @@
                     && 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);
                 }
             }
@@ -295 +295 @@
                     && 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;
@@ -309 +309 @@
         case ArithTrunc: {
             if (isInt32OrBooleanSpeculation(node->getHeapPrediction()) && m_graph.roundShouldSpeculateInt32(node, m_pass))
-                changed |= setPrediction(SpecInt32);
+                changed |= setPrediction(SpecInt32Only);
             else
                 changed |= setPrediction(SpecBytecodeDouble);
@@ -319 +319 @@
             if (isInt32OrBooleanSpeculationForArithmetic(child)
                 && node->canSpeculateInt32(m_pass))
-                changed |= mergePrediction(SpecInt32);
+                changed |= mergePrediction(SpecInt32Only);
             else
                 changed |= mergePrediction(speculatedDoubleTypeForPrediction(child));
@@ -338 +338 @@
             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:
@@ -354 +354 @@
             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:
@@ -365 +365 @@
             case Array::Uint16Array:
             case Array::Int32Array:
-                changed |= mergePrediction(SpecInt32);
+                changed |= mergePrediction(SpecInt32Only);
                 break;
             default:
@@ -384 +384 @@
 
                 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;
                 }
@@ -483 +483 @@
                 && isFullNumberSpeculation(right)
                 && !m_graph.addShouldSpeculateInt32(node, m_pass)
-                && !m_graph.addShouldSpeculateMachineInt(node))
+                && !m_graph.addShouldSpeculateAnyInt(node))
                 ballot = VoteDouble;
             else
@@ -502 +502 @@
                 && isFullNumberSpeculation(right)
                 && !m_graph.binaryArithShouldSpeculateInt32(node, m_pass)
-                && !m_graph.binaryArithShouldSpeculateMachineInt(node, m_pass))
+                && !m_graph.binaryArithShouldSpeculateAnyInt(node, m_pass))
                 ballot = VoteDouble;
             else
@@ -559 +559 @@
                 node->variableAccessData()->vote(VoteDouble, weight);
             else if (!isFullNumberSpeculation(prediction)
-                || isInt32Speculation(prediction) || isMachineIntSpeculation(prediction))
+                || isInt32Speculation(prediction) || isAnyIntSpeculation(prediction))
                 node->variableAccessData()->vote(VoteValue, weight);
             break;
@@ -644 +644 @@
         case JSConstant: {
             SpeculatedType type = speculationFromValue(m_currentNode->asJSValue());
-            if (type == SpecInt52AsDouble && enableInt52())
-                type = SpecInt52;
+            if (type == SpecAnyIntAsDouble && enableInt52())
+                type = SpecInt52Only;
             setPrediction(type);
             break;
@@ -662 +662 @@
         case ArithIMul:
         case ArithClz32: {
-            setPrediction(SpecInt32);
+            setPrediction(SpecInt32Only);
             break;
         }
@@ -718 +718 @@
             
         case GetArgumentCount: {
-            setPrediction(SpecInt32);
+            setPrediction(SpecInt32Only);
             break;
         }
 
         case GetRestLength: {
-            setPrediction(SpecInt32);
+            setPrediction(SpecInt32Only);
             break;
         }
@@ -729 +729 @@
         case GetTypedArrayByteOffset:
         case GetArrayLength: {
-            setPrediction(SpecInt32);
+            setPrediction(SpecInt32Only);
             break;
         }
 
         case StringCharCodeAt: {
-            setPrediction(SpecInt32);
+            setPrediction(SpecInt32Only);
             break;
         }
@@ -867 +867 @@
         case FiatInt52: {
             RELEASE_ASSERT(enableInt52());
-            setPrediction(SpecMachineInt);
+            setPrediction(SpecAnyInt);
             break;
         }
@@ -880 +880 @@
 
         case GetEnumerableLength: {
-            setPrediction(SpecInt32);
+            setPrediction(SpecInt32Only);
             break;
         }

trunk/Source/JavaScriptCore/dfg/DFGSSALoweringPhase.cpp ¶

@@ -84 +84 @@
             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);
                 
@@ -107 +107 @@
         
         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;

trunk/Source/JavaScriptCore/dfg/DFGSafeToExecute.h ¶

@@ -70 +70 @@
         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;

trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp ¶

@@ -610 +610 @@
 #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)
@@ -2637 +2637 @@
     
 #if USE(JSVALUE64)
-    if (node->shouldSpeculateMachineInt()) {
+    if (node->shouldSpeculateAnyInt()) {
         m_jit.zeroExtend32ToPtr(resultReg, resultReg);
         strictInt52Result(resultReg, node);
@@ -3562 +3562 @@
         // 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);
@@ -3754 +3754 @@
         // 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);
@@ -3876 +3876 @@
         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);
@@ -6901 +6901 @@
 void SpeculativeJIT::speculateInt32(Edge edge)
 {
-    if (!needsTypeCheck(edge, SpecInt32))
+    if (!needsTypeCheck(edge, SpecInt32Only))
         return;
     
@@ -6921 +6921 @@
     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(
@@ -7249 +7249 @@
 #else
     DFG_TYPE_CHECK(
-        regs, edge, ~SpecInt32,
+        regs, edge, ~SpecInt32Only,
         m_jit.branch32(MacroAssembler::Equal, regs.tagGPR(), MacroAssembler::TrustedImm32(JSValue::Int32Tag)));
     DFG_TYPE_CHECK(
@@ -7272 +7272 @@
         break;
     case KnownInt32Use:
-        ASSERT(!needsTypeCheck(edge, SpecInt32));
+        ASSERT(!needsTypeCheck(edge, SpecInt32Only));
         break;
     case DoubleRepUse:
@@ -7278 +7278 @@
         break;
     case Int52RepUse:
-        ASSERT(!needsTypeCheck(edge, SpecMachineInt));
+        ASSERT(!needsTypeCheck(edge, SpecAnyInt));
         break;
     case KnownCellUse:
@@ -7302 +7302 @@
         break;
 #if USE(JSVALUE64)
-    case MachineIntUse:
-        speculateMachineInt(edge);
-        break;
-    case DoubleRepMachineIntUse:
-        speculateDoubleRepMachineInt(edge);
+    case AnyIntUse:
+        speculateAnyInt(edge);
+        break;
+    case DoubleRepAnyIntUse:
+        speculateDoubleRepAnyInt(edge);
         break;
 #endif

trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.h ¶

@@ -565 +565 @@
     }
     
-    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); }
@@ -2675 +2675 @@
     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);

trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp ¶

@@ -944 +944 @@
     AbstractValue& value = m_state.forNode(edge);
     SpeculatedType type = value.m_type;
-    ASSERT(edge.useKind() != KnownInt32Use || !(value.m_type & ~SpecInt32));
-
-    m_interpreter.filter(value, SpecInt32);
+    ASSERT(edge.useKind() != KnownInt32Use || !(value.m_type & ~SpecInt32Only));
+
+    m_interpreter.filter(value, SpecInt32Only);
     if (value.isClear()) {
         terminateSpeculativeExecution(Uncountable, JSValueRegs(), 0);
@@ -973 +973 @@
 
         // 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)));
 
@@ -991 +991 @@
         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);
@@ -1900 +1900 @@
         }
         case Int52RepUse: 
-        case MachineIntUse:
-        case DoubleRepMachineIntUse: {
+        case AnyIntUse:
+        case DoubleRepAnyIntUse: {
             RELEASE_ASSERT_NOT_REACHED();   
             break;

trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp ¶

@@ -902 +902 @@
     AbstractValue& value = m_state.forNode(edge);
     SpeculatedType type = value.m_type;
-    ASSERT(edge.useKind() != KnownInt32Use || !(value.m_type & ~SpecInt32));
-
-    m_interpreter.filter(value, SpecInt32);
+    ASSERT(edge.useKind() != KnownInt32Use || !(value.m_type & ~SpecInt32Only));
+
+    m_interpreter.filter(value, SpecInt32Only);
     if (value.isClear()) {
         terminateSpeculativeExecution(Uncountable, JSValueRegs(), 0);
@@ -959 +959 @@
 
     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);
@@ -1046 +1046 @@
     AbstractValue& value = m_state.forNode(edge);
 
-    m_interpreter.filter(value, SpecMachineInt);
+    m_interpreter.filter(value, SpecAnyInt);
     if (value.isClear()) {
         terminateSpeculativeExecution(Uncountable, JSValueRegs(), 0);
@@ -1061 +1061 @@
         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;
@@ -1132 +1132 @@
 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();
@@ -1933 +1933 @@
             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);
@@ -1988 +1988 @@
         case DoubleRepUse:
         case DoubleRepRealUse:
-        case DoubleRepMachineIntUse: {
+        case DoubleRepAnyIntUse: {
             SpeculateDoubleOperand op(this, node->child1());
             FPRTemporary scratch(this, op);
@@ -2223 +2223 @@
         }
             
-        case MachineIntUse: {
+        case AnyIntUse: {
             GPRTemporary result(this);
             GPRReg resultGPR = result.gpr();
             
-            convertMachineInt(node->child1(), resultGPR);
+            convertAnyInt(node->child1(), resultGPR);
             
             strictInt52Result(resultGPR, node);
@@ -2233 +2233 @@
         }
             
-        case DoubleRepMachineIntUse: {
+        case DoubleRepAnyIntUse: {
             SpeculateDoubleOperand value(this, node->child1());
             FPRReg valueFPR = value.fpr();
@@ -2245 +2245 @@
             
             DFG_TYPE_CHECK_WITH_EXIT_KIND(Int52Overflow,
-                JSValueRegs(), node->child1(), SpecInt52AsDouble,
+                JSValueRegs(), node->child1(), SpecAnyIntAsDouble,
                 m_jit.branch64(
                     JITCompiler::Equal, resultGPR,
@@ -2828 +2828 @@
             if (arrayMode.type() == Array::Int32) {
                 DFG_TYPE_CHECK(
-                    JSValueRegs(valueReg), child3, SpecInt32,
+                    JSValueRegs(valueReg), child3, SpecInt32Only,
                     m_jit.branch64(
                         MacroAssembler::Below, valueReg, GPRInfo::tagTypeNumberRegister));
@@ -3220 +3220 @@
             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));
@@ -3600 +3600 @@
                     if (hasInt32(node->indexingType())) {
                         DFG_TYPE_CHECK(
-                            JSValueRegs(opGPR), use, SpecInt32,
+                            JSValueRegs(opGPR), use, SpecInt32Only,
                             m_jit.branch64(
                                 MacroAssembler::Below, opGPR, GPRInfo::tagTypeNumberRegister));
@@ -3666 +3666 @@
                 if (hasInt32(node->indexingType())) {
                     DFG_TYPE_CHECK(
-                        JSValueRegs(opGPR), use, SpecInt32,
+                        JSValueRegs(opGPR), use, SpecInt32Only,
                         m_jit.branch64(
                             MacroAssembler::Below, opGPR, GPRInfo::tagTypeNumberRegister));
@@ -4999 +4999 @@
             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)
@@ -5208 +5208 @@
 }
 
-void SpeculativeJIT::convertMachineInt(Edge valueEdge, GPRReg resultGPR)
+void SpeculativeJIT::convertAnyInt(Edge valueEdge, GPRReg resultGPR)
 {
     JSValueOperand value(this, valueEdge, ManualOperandSpeculation);
@@ -5225 +5225 @@
 
     DFG_TYPE_CHECK(
-        JSValueRegs(valueGPR), valueEdge, SpecInt32 | SpecInt52AsDouble,
+        JSValueRegs(valueGPR), valueEdge, SpecInt32Only | SpecAnyIntAsDouble,
         m_jit.branch64(
             JITCompiler::Equal, resultGPR,
@@ -5232 +5232 @@
 }
 
-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;
     
@@ -5257 +5257 @@
     
     DFG_TYPE_CHECK(
-        JSValueRegs(), edge, SpecInt52AsDouble,
+        JSValueRegs(), edge, SpecAnyIntAsDouble,
         m_jit.branch64(
             JITCompiler::Equal, resultGPR,

trunk/Source/JavaScriptCore/dfg/DFGUseKind.cpp ¶

@@ -50 +50 @@
         out.print("Int52Rep");
         return;
-    case MachineIntUse:
-        out.print("MachineInt");
+    case AnyIntUse:
+        out.print("AnyInt");
         return;
     case NumberUse:
@@ -65 +65 @@
         out.print("DoubleRepReal");
         return;
-    case DoubleRepMachineIntUse:
-        out.print("DoubleRepMachineInt");
+    case DoubleRepAnyIntUse:
+        out.print("DoubleRepAnyInt");
         return;
     case BooleanUse:

trunk/Source/JavaScriptCore/dfg/DFGUseKind.h ¶

@@ -45 +45 @@
     Int32Use,
     KnownInt32Use,
-    MachineIntUse,
+    AnyIntUse,
     NumberUse,
     RealNumberUse,
@@ -75 +75 @@
     DoubleRepUse,
     DoubleRepRealUse,
-    DoubleRepMachineIntUse,
+    DoubleRepAnyIntUse,
 
     // 3. The Int52 representation for an unboxed integer value that must be stored
@@ -91 +91 @@
     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;
@@ -104 +104 @@
     case DoubleRepRealUse:
         return SpecDoubleReal;
-    case DoubleRepMachineIntUse:
-        return SpecInt52AsDouble;
+    case DoubleRepAnyIntUse:
+        return SpecAnyIntAsDouble;
     case BooleanUse:
     case KnownBooleanUse:
@@ -185 +185 @@
     case DoubleRepUse:
     case DoubleRepRealUse:
-    case MachineIntUse:
-    case DoubleRepMachineIntUse:
+    case AnyIntUse:
+    case DoubleRepAnyIntUse:
         return true;
     default:
@@ -198 +198 @@
     case DoubleRepUse:
     case DoubleRepRealUse:
-    case DoubleRepMachineIntUse:
+    case DoubleRepAnyIntUse:
         return true;
     default:

trunk/Source/JavaScriptCore/dfg/DFGValidate.cpp ¶

@@ -695 +695 @@
             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);
     }
 

trunk/Source/JavaScriptCore/dfg/DFGVariableAccessData.cpp ¶

@@ -157 +157 @@
     if (type & ~SpecBytecodeNumber)
         type |= SpecDoublePureNaN;
-    if (type & SpecMachineInt)
-        type |= SpecInt52AsDouble;
+    if (type & SpecAnyInt)
+        type |= SpecAnyIntAsDouble;
     return checkAndSet(m_prediction, type);
 }
@@ -181 +181 @@
     
     // 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);
 }
 

trunk/Source/JavaScriptCore/ftl/FTLCapabilities.cpp ¶

@@ -501 +501 @@
                 case StringIdentUse:
                 case NotStringVarUse:
-                case MachineIntUse:
-                case DoubleRepMachineIntUse:
+                case AnyIntUse:
+                case DoubleRepAnyIntUse:
                     // These are OK.
                     break;

trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp ¶

@@ -1083 +1083 @@
     void compileInt52Constant()
     {
-        int64_t value = m_node->asMachineInt();
+        int64_t value = m_node->asAnyInt();
         
         setInt52(m_out.constInt64(value << JSValue::int52ShiftAmount));
@@ -1262 +1262 @@
             return;
             
-        case MachineIntUse:
+        case AnyIntUse:
             setStrictInt52(
                 jsValueToStrictInt52(
@@ -1268 +1268 @@
             return;
             
-        case DoubleRepMachineIntUse:
+        case DoubleRepAnyIntUse:
             setStrictInt52(
                 doubleToStrictInt52(
@@ -1539 +1539 @@
             
         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);
@@ -2086 +2086 @@
             
         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);
@@ -2859 +2859 @@
                     }
                     
-                    if (m_node->shouldSpeculateMachineInt()) {
+                    if (m_node->shouldSpeculateAnyInt()) {
                         setStrictInt52(m_out.zeroExt(result, m_out.int64));
                         return;
@@ -3000 +3000 @@
                 
                 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(
@@ -3250 +3250 @@
                 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;
@@ -9314 +9314 @@
             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);
@@ -9320 +9320 @@
         }
 
-        DFG_ASSERT(m_graph, m_node, !(provenType(edge) & SpecInt32));
+        DFG_ASSERT(m_graph, m_node, !(provenType(edge) & SpecInt32Only));
         terminate(Uncountable);
         return m_out.int32Zero;
@@ -9569 +9569 @@
         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);
@@ -9619 +9619 @@
     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);
@@ -9625 +9625 @@
     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);
@@ -9667 +9667 @@
             
         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
@@ -9686 +9686 @@
             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)));
             
@@ -9702 +9702 @@
             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)));
         
@@ -9849 +9849 @@
             ASSERT(!m_interpreter.needsTypeCheck(edge));
             break;
-        case MachineIntUse:
-            speculateMachineInt(edge);
+        case AnyIntUse:
+            speculateAnyInt(edge);
             break;
         case ObjectUse:
@@ -9894 +9894 @@
             speculateDoubleRepReal(edge);
             break;
-        case DoubleRepMachineIntUse:
-            speculateDoubleRepMachineInt(edge);
+        case DoubleRepAnyIntUse:
+            speculateDoubleRepAnyInt(edge);
             break;
         case BooleanUse:
@@ -9948 +9948 @@
     }
     
-    void speculateMachineInt(Edge edge)
+    void speculateAnyInt(Edge edge)
     {
         if (!m_interpreter.needsTypeCheck(edge))
@@ -10346 +10346 @@
     }
     
-    void speculateDoubleRepMachineInt(Edge edge)
+    void speculateDoubleRepAnyInt(Edge edge)
     {
         if (!m_interpreter.needsTypeCheck(edge))

trunk/Source/JavaScriptCore/jit/JITOpcodes.cpp ¶

@@ -1298 +1298 @@
         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)

trunk/Source/JavaScriptCore/jit/JITOpcodes32_64.cpp ¶

@@ -1299 +1299 @@
     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) {

trunk/Source/JavaScriptCore/runtime/JSCJSValue.h ¶

@@ -215 +215 @@
     int32_t asInt32() const;
     uint32_t asUInt32() const;
-    int64_t asMachineInt() const;
+    int64_t asAnyInt() const;
     double asDouble() const;
     bool asBoolean() const;
@@ -233 +233 @@
     bool isUndefinedOrNull() const;
     bool isBoolean() const;
-    bool isMachineInt() const;
+    bool isAnyInt() const;
     bool isNumber() const;
     bool isString() const;

trunk/Source/JavaScriptCore/runtime/JSCJSValueInlines.h ¶

@@ -531 +531 @@
 }
 
-inline bool JSValue::isMachineInt() const
+inline bool JSValue::isAnyInt() const
 {
     if (isInt32())
@@ -540 +540 @@
 }
 
-inline int64_t JSValue::asMachineInt() const
-{
-    ASSERT(isMachineInt());
+inline int64_t JSValue::asAnyInt() const
+{
+    ASSERT(isAnyInt());
     if (isInt32())
         return asInt32();

trunk/Source/JavaScriptCore/runtime/RuntimeType.cpp ¶

@@ -43 +43 @@
     if (value.isNull())
         return TypeNull;
-    if (value.isMachineInt())
-        return TypeMachineInt;
+    if (value.isAnyInt())
+        return TypeAnyInt;
     if (value.isNumber())
         return TypeNumber;
@@ -67 +67 @@
     if (type == TypeNull)
         return ASCIILiteral("Null");
-    if (type == TypeMachineInt)
+    if (type == TypeAnyInt)
         return ASCIILiteral("Integer");
     if (type == TypeNumber)

trunk/Source/JavaScriptCore/runtime/RuntimeType.h ¶

@@ -38 +38 @@
     TypeNull               = 0x4,
     TypeBoolean            = 0x8,
-    TypeMachineInt         = 0x10,
+    TypeAnyInt             = 0x10,
     TypeNumber             = 0x20,
     TypeString             = 0x40,
@@ -47 +47 @@
 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;

trunk/Source/JavaScriptCore/runtime/TypeSet.cpp ¶

@@ -101 +101 @@
     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 ");
@@ -180 +180 @@
     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))
@@ -196 +196 @@
     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))
@@ -235 +235 @@
         .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)
@@ -278 +278 @@
         json.appendLiteral("\"Boolean\"");
     }
-    if (m_seenTypes & TypeMachineInt) {
+    if (m_seenTypes & TypeAnyInt) {
         if (hasAnItem)
             json.append(',');