Ignore:
Timestamp:
Jun 6, 2012, 6:35:59 PM (13 years ago)
Author:
[email protected]
Message:

PredictedType should be called SpeculatedType
​https://bugs.webkit.org/show_bug.cgi?id=88477

Rubber stamped by Gavin Barraclough.

  • CMakeLists.txt:
  • GNUmakefile.list.am:
  • JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
  • JavaScriptCore.xcodeproj/project.pbxproj:
  • Target.pri:
  • bytecode/CodeBlock.cpp:

(JSC::CodeBlock::shouldOptimizeNow):
(JSC::CodeBlock::dumpValueProfiles):

  • bytecode/CodeBlock.h:

(JSC::CodeBlock::valueProfilePredictionForBytecodeOffset):

  • bytecode/LazyOperandValueProfile.cpp:

(JSC::LazyOperandValueProfileParser::prediction):

  • bytecode/LazyOperandValueProfile.h:

(LazyOperandValueProfileParser):

  • bytecode/PredictedType.cpp: Removed.
  • bytecode/PredictedType.h: Removed.
  • bytecode/SpeculatedType.cpp: Copied from Source/JavaScriptCore/bytecode/PredictedType.cpp.

(JSC::speculationToString):
(JSC::speculationToAbbreviatedString):
(JSC::speculationFromClassInfo):
(JSC::speculationFromStructure):
(JSC::speculationFromCell):
(JSC::speculationFromValue):

  • bytecode/SpeculatedType.h: Copied from Source/JavaScriptCore/bytecode/PredictedType.h.

(JSC):
(JSC::isAnySpeculation):
(JSC::isCellSpeculation):
(JSC::isObjectSpeculation):
(JSC::isFinalObjectSpeculation):
(JSC::isFinalObjectOrOtherSpeculation):
(JSC::isFixedIndexedStorageObjectSpeculation):
(JSC::isStringSpeculation):
(JSC::isArraySpeculation):
(JSC::isFunctionSpeculation):
(JSC::isInt8ArraySpeculation):
(JSC::isInt16ArraySpeculation):
(JSC::isInt32ArraySpeculation):
(JSC::isUint8ArraySpeculation):
(JSC::isUint8ClampedArraySpeculation):
(JSC::isUint16ArraySpeculation):
(JSC::isUint32ArraySpeculation):
(JSC::isFloat32ArraySpeculation):
(JSC::isFloat64ArraySpeculation):
(JSC::isArgumentsSpeculation):
(JSC::isActionableIntMutableArraySpeculation):
(JSC::isActionableFloatMutableArraySpeculation):
(JSC::isActionableTypedMutableArraySpeculation):
(JSC::isActionableMutableArraySpeculation):
(JSC::isActionableArraySpeculation):
(JSC::isArrayOrOtherSpeculation):
(JSC::isMyArgumentsSpeculation):
(JSC::isInt32Speculation):
(JSC::isDoubleRealSpeculation):
(JSC::isDoubleSpeculation):
(JSC::isNumberSpeculation):
(JSC::isBooleanSpeculation):
(JSC::isOtherSpeculation):
(JSC::isEmptySpeculation):
(JSC::mergeSpeculations):
(JSC::mergeSpeculation):

  • bytecode/StructureSet.h:

(JSC::StructureSet::speculationFromStructures):

  • bytecode/ValueProfile.h:

(JSC::ValueProfileBase::ValueProfileBase):
(JSC::ValueProfileBase::dump):
(JSC::ValueProfileBase::computeUpdatedPrediction):
(ValueProfileBase):

  • dfg/DFGAbstractState.cpp:

(JSC::DFG::AbstractState::initialize):
(JSC::DFG::AbstractState::execute):
(JSC::DFG::AbstractState::mergeStateAtTail):

  • dfg/DFGAbstractState.h:

(JSC::DFG::AbstractState::speculateInt32Unary):
(JSC::DFG::AbstractState::speculateNumberUnary):
(JSC::DFG::AbstractState::speculateBooleanUnary):
(JSC::DFG::AbstractState::speculateInt32Binary):
(JSC::DFG::AbstractState::speculateNumberBinary):

  • dfg/DFGAbstractValue.h:

(JSC::DFG::StructureAbstractValue::filter):
(JSC::DFG::StructureAbstractValue::speculationFromStructures):
(JSC::DFG::AbstractValue::AbstractValue):
(JSC::DFG::AbstractValue::clear):
(JSC::DFG::AbstractValue::isClear):
(JSC::DFG::AbstractValue::makeTop):
(JSC::DFG::AbstractValue::clobberStructures):
(JSC::DFG::AbstractValue::isTop):
(JSC::DFG::AbstractValue::set):
(JSC::DFG::AbstractValue::merge):
(JSC::DFG::AbstractValue::filter):
(JSC::DFG::AbstractValue::validateIgnoringValue):
(JSC::DFG::AbstractValue::validate):
(JSC::DFG::AbstractValue::checkConsistency):
(JSC::DFG::AbstractValue::dump):
(AbstractValue):

  • dfg/DFGArgumentPosition.h:

(JSC::DFG::ArgumentPosition::ArgumentPosition):
(JSC::DFG::ArgumentPosition::mergeArgumentAwareness):
(JSC::DFG::ArgumentPosition::prediction):
(ArgumentPosition):

  • dfg/DFGArgumentsSimplificationPhase.cpp:

(JSC::DFG::ArgumentsSimplificationPhase::run):

  • dfg/DFGByteCodeParser.cpp:

(ByteCodeParser):
(JSC::DFG::ByteCodeParser::injectLazyOperandSpeculation):
(JSC::DFG::ByteCodeParser::getLocal):
(JSC::DFG::ByteCodeParser::getArgument):
(JSC::DFG::ByteCodeParser::addCall):
(JSC::DFG::ByteCodeParser::getSpeculationWithoutOSRExit):
(JSC::DFG::ByteCodeParser::getSpeculation):
(InlineStackEntry):
(JSC::DFG::ByteCodeParser::handleCall):
(JSC::DFG::ByteCodeParser::handleIntrinsic):
(JSC::DFG::ByteCodeParser::handleGetById):
(JSC::DFG::ByteCodeParser::parseBlock):
(JSC::DFG::ByteCodeParser::fixVariableAccessSpeculations):
(JSC::DFG::ByteCodeParser::parse):

  • dfg/DFGCSEPhase.cpp:

(JSC::DFG::CSEPhase::getIndexedPropertyStorageLoadElimination):
(JSC::DFG::CSEPhase::performNodeCSE):

  • dfg/DFGConstantFoldingPhase.cpp:

(JSC::DFG::ConstantFoldingPhase::run):

  • dfg/DFGFixupPhase.cpp:

(JSC::DFG::FixupPhase::fixupNode):
(JSC::DFG::FixupPhase::fixDoubleEdge):

  • dfg/DFGGraph.cpp:

(JSC::DFG::Graph::nameOfVariableAccessData):
(JSC::DFG::Graph::dump):
(JSC::DFG::Graph::predictArgumentTypes):

  • dfg/DFGGraph.h:

(JSC::DFG::Graph::getJSConstantSpeculation):
(JSC::DFG::Graph::isPredictedNumerical):
(JSC::DFG::Graph::byValIsPure):

  • dfg/DFGJITCompiler.h:

(JSC::DFG::JITCompiler::getSpeculation):

  • dfg/DFGNode.h:

(JSC::DFG::Node::Node):
(JSC::DFG::Node::getHeapPrediction):
(JSC::DFG::Node::predictHeap):
(JSC::DFG::Node::prediction):
(JSC::DFG::Node::predict):
(JSC::DFG::Node::shouldSpeculateInteger):
(JSC::DFG::Node::shouldSpeculateDouble):
(JSC::DFG::Node::shouldSpeculateNumber):
(JSC::DFG::Node::shouldSpeculateBoolean):
(JSC::DFG::Node::shouldSpeculateFinalObject):
(JSC::DFG::Node::shouldSpeculateFinalObjectOrOther):
(JSC::DFG::Node::shouldSpeculateArray):
(JSC::DFG::Node::shouldSpeculateArguments):
(JSC::DFG::Node::shouldSpeculateInt8Array):
(JSC::DFG::Node::shouldSpeculateInt16Array):
(JSC::DFG::Node::shouldSpeculateInt32Array):
(JSC::DFG::Node::shouldSpeculateUint8Array):
(JSC::DFG::Node::shouldSpeculateUint8ClampedArray):
(JSC::DFG::Node::shouldSpeculateUint16Array):
(JSC::DFG::Node::shouldSpeculateUint32Array):
(JSC::DFG::Node::shouldSpeculateFloat32Array):
(JSC::DFG::Node::shouldSpeculateFloat64Array):
(JSC::DFG::Node::shouldSpeculateArrayOrOther):
(JSC::DFG::Node::shouldSpeculateObject):
(JSC::DFG::Node::shouldSpeculateCell):
(Node):

  • dfg/DFGPredictionPropagationPhase.cpp:

(JSC::DFG::PredictionPropagationPhase::setPrediction):
(JSC::DFG::PredictionPropagationPhase::mergePrediction):
(JSC::DFG::PredictionPropagationPhase::propagate):
(JSC::DFG::PredictionPropagationPhase::doRoundOfDoubleVoting):

  • dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::fillStorage):
(JSC::DFG::SpeculativeJIT::writeBarrier):
(JSC::DFG::GPRTemporary::GPRTemporary):
(JSC::DFG::FPRTemporary::FPRTemporary):
(JSC::DFG::SpeculativeJIT::compilePeepHoleDoubleBranch):
(JSC::DFG::SpeculativeJIT::compilePeepHoleObjectEquality):
(JSC::DFG::SpeculativeJIT::compilePeepHoleBranch):
(JSC::DFG::SpeculativeJIT::compile):
(JSC::DFG::SpeculativeJIT::checkArgumentTypes):
(JSC::DFG::SpeculativeJIT::compileGetCharCodeAt):
(JSC::DFG::SpeculativeJIT::compileGetByValOnString):
(JSC::DFG::SpeculativeJIT::compileValueToInt32):
(JSC::DFG::SpeculativeJIT::compileDoubleAsInt32):
(JSC::DFG::SpeculativeJIT::compileInt32ToDouble):
(JSC::DFG::SpeculativeJIT::compileGetTypedArrayLength):
(JSC::DFG::SpeculativeJIT::compileGetByValOnIntTypedArray):
(JSC::DFG::SpeculativeJIT::compilePutByValForIntTypedArray):
(JSC::DFG::SpeculativeJIT::compileGetByValOnFloatTypedArray):
(JSC::DFG::SpeculativeJIT::compilePutByValForFloatTypedArray):
(JSC::DFG::SpeculativeJIT::compileInstanceOf):
(JSC::DFG::SpeculativeJIT::compileAdd):
(JSC::DFG::SpeculativeJIT::compileArithSub):
(JSC::DFG::SpeculativeJIT::compileArithNegate):
(JSC::DFG::SpeculativeJIT::compileArithMul):
(JSC::DFG::SpeculativeJIT::compileArithMod):
(JSC::DFG::SpeculativeJIT::compare):
(JSC::DFG::SpeculativeJIT::compileStrictEq):
(JSC::DFG::SpeculativeJIT::compileGetIndexedPropertyStorage):
(JSC::DFG::SpeculativeJIT::compileGetByValOnArguments):
(JSC::DFG::SpeculativeJIT::compileGetArgumentsLength):
(JSC::DFG::SpeculativeJIT::compileRegExpExec):

  • dfg/DFGSpeculativeJIT.h:

(DFG):
(JSC::DFG::ValueSource::forSpeculation):
(SpeculativeJIT):
(GPRTemporary):
(FPRTemporary):
(JSC::DFG::SpecDoubleOperand::SpecDoubleOperand):
(JSC::DFG::SpecDoubleOperand::~SpecDoubleOperand):
(JSC::DFG::SpecDoubleOperand::fpr):
(JSC::DFG::SpecCellOperand::SpecCellOperand):
(JSC::DFG::SpecCellOperand::~SpecCellOperand):
(JSC::DFG::SpecCellOperand::gpr):
(JSC::DFG::SpecBooleanOperand::SpecBooleanOperand):
(JSC::DFG::SpecBooleanOperand::~SpecBooleanOperand):
(JSC::DFG::SpecBooleanOperand::gpr):

  • dfg/DFGSpeculativeJIT32_64.cpp:

(JSC::DFG::SpeculativeJIT::fillSpeculateIntInternal):
(JSC::DFG::SpeculativeJIT::fillSpecDouble):
(JSC::DFG::SpeculativeJIT::fillSpecCell):
(JSC::DFG::SpeculativeJIT::fillSpecBoolean):
(JSC::DFG::SpeculativeJIT::compileObjectEquality):
(JSC::DFG::SpeculativeJIT::compileObjectToObjectOrOtherEquality):
(JSC::DFG::SpeculativeJIT::compilePeepHoleObjectToObjectOrOtherEquality):
(JSC::DFG::SpeculativeJIT::compileDoubleCompare):
(JSC::DFG::SpeculativeJIT::compileLogicalNot):
(JSC::DFG::SpeculativeJIT::emitBranch):
(JSC::DFG::SpeculativeJIT::compile):

  • dfg/DFGSpeculativeJIT64.cpp:

(JSC::DFG::SpeculativeJIT::fillSpeculateIntInternal):
(JSC::DFG::SpeculativeJIT::fillSpecDouble):
(JSC::DFG::SpeculativeJIT::fillSpecCell):
(JSC::DFG::SpeculativeJIT::fillSpecBoolean):
(JSC::DFG::SpeculativeJIT::compileObjectEquality):
(JSC::DFG::SpeculativeJIT::compileObjectToObjectOrOtherEquality):
(JSC::DFG::SpeculativeJIT::compilePeepHoleObjectToObjectOrOtherEquality):
(JSC::DFG::SpeculativeJIT::compileDoubleCompare):
(JSC::DFG::SpeculativeJIT::compileLogicalNot):
(JSC::DFG::SpeculativeJIT::emitBranch):
(JSC::DFG::SpeculativeJIT::compile):

  • dfg/DFGVariableAccessData.h:

(JSC::DFG::VariableAccessData::VariableAccessData):
(JSC::DFG::VariableAccessData::predict):
(JSC::DFG::VariableAccessData::nonUnifiedPrediction):
(JSC::DFG::VariableAccessData::prediction):
(JSC::DFG::VariableAccessData::argumentAwarePrediction):
(JSC::DFG::VariableAccessData::mergeArgumentAwarePrediction):
(JSC::DFG::VariableAccessData::shouldUseDoubleFormatAccordingToVote):
(JSC::DFG::VariableAccessData::makePredictionForDoubleFormat):
(VariableAccessData):

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r119655 r119660  
    10291029    dataLog("SpecInt@%d   ", nodeIndex);
    10301030#endif
    1031     PredictedType type = m_state.forNode(nodeIndex).m_type;
     1031    SpeculatedType type = m_state.forNode(nodeIndex).m_type;
    10321032    Node& node = at(nodeIndex);
    10331033    VirtualRegister virtualRegister = node.virtualRegister();
    … …  
    10871087        GPRReg gpr = info.gpr();
    10881088        m_gprs.lock(gpr);
    1089         if (!isInt32Prediction(type))
     1089        if (!isInt32Speculation(type))
    10901090            speculationCheck(BadType, JSValueRegs(gpr), nodeIndex, m_jit.branchPtr(MacroAssembler::Below, gpr, GPRInfo::tagTypeNumberRegister));
    10911091        info.fillJSValue(gpr, DataFormatJSInteger);
    … …  
    11761176    dataLog("SpecDouble@%d   ", nodeIndex);
    11771177#endif
    1178     PredictedType type = m_state.forNode(nodeIndex).m_type;
     1178    SpeculatedType type = m_state.forNode(nodeIndex).m_type;
    11791179    Node& node = at(nodeIndex);
    11801180    VirtualRegister virtualRegister = node.virtualRegister();
    … …  
    12611261        JITCompiler::Jump isInteger = m_jit.branchPtr(MacroAssembler::AboveOrEqual, jsValueGpr, GPRInfo::tagTypeNumberRegister);
    12621262
    1263         if (!isNumberPrediction(type))
     1263        if (!isNumberSpeculation(type))
    12641264            speculationCheck(BadType, JSValueRegs(jsValueGpr), nodeIndex, m_jit.branchTestPtr(MacroAssembler::Zero, jsValueGpr, GPRInfo::tagTypeNumberRegister));
    12651265
    … …  
    13291329    dataLog("SpecCell@%d   ", nodeIndex);
    13301330#endif
    1331     PredictedType type = m_state.forNode(nodeIndex).m_type;
     1331    SpeculatedType type = m_state.forNode(nodeIndex).m_type;
    13321332    Node& node = at(nodeIndex);
    13331333    VirtualRegister virtualRegister = node.virtualRegister();
    … …  
    13591359
    13601360        info.fillJSValue(gpr, DataFormatJS);
    1361         if (!isCellPrediction(type))
     1361        if (!isCellSpeculation(type))
    13621362            speculationCheck(BadType, JSValueRegs(gpr), nodeIndex, m_jit.branchTestPtr(MacroAssembler::NonZero, gpr, GPRInfo::tagMaskRegister));
    13631363        info.fillJSValue(gpr, DataFormatJSCell);
    … …  
    13751375        GPRReg gpr = info.gpr();
    13761376        m_gprs.lock(gpr);
    1377         if (!isCellPrediction(type))
     1377        if (!isCellSpeculation(type))
    13781378            speculationCheck(BadType, JSValueRegs(gpr), nodeIndex, m_jit.branchTestPtr(MacroAssembler::NonZero, gpr, GPRInfo::tagMaskRegister));
    13791379        info.fillJSValue(gpr, DataFormatJSCell);
    … …  
    14041404    dataLog("SpecBool@%d   ", nodeIndex);
    14051405#endif
    1406     PredictedType type = m_state.forNode(nodeIndex).m_type;
     1406    SpeculatedType type = m_state.forNode(nodeIndex).m_type;
    14071407    Node& node = at(nodeIndex);
    14081408    VirtualRegister virtualRegister = node.virtualRegister();
    … …  
    14341434
    14351435        info.fillJSValue(gpr, DataFormatJS);
    1436         if (!isBooleanPrediction(type)) {
     1436        if (!isBooleanSpeculation(type)) {
    14371437            m_jit.xorPtr(TrustedImm32(static_cast<int32_t>(ValueFalse)), gpr);
    14381438            speculationCheck(BadType, JSValueRegs(gpr), nodeIndex, m_jit.branchTestPtr(MacroAssembler::NonZero, gpr, TrustedImm32(static_cast<int32_t>(~1))), SpeculationRecovery(BooleanSpeculationCheck, gpr, InvalidGPRReg));
    … …  
    14531453        GPRReg gpr = info.gpr();
    14541454        m_gprs.lock(gpr);
    1455         if (!isBooleanPrediction(type)) {
     1455        if (!isBooleanSpeculation(type)) {
    14561456            m_jit.xorPtr(TrustedImm32(static_cast<int32_t>(ValueFalse)), gpr);
    14571457            speculationCheck(BadType, JSValueRegs(gpr), nodeIndex, m_jit.branchTestPtr(MacroAssembler::NonZero, gpr, TrustedImm32(static_cast<int32_t>(~1))), SpeculationRecovery(BooleanSpeculationCheck, gpr, InvalidGPRReg));
    … …  
    15001500}
    15011501
    1502 void SpeculativeJIT::compileObjectEquality(Node& node, const ClassInfo* classInfo, PredictionChecker predictionCheck)
     1502void SpeculativeJIT::compileObjectEquality(Node& node, const ClassInfo* classInfo, SpeculatedTypeChecker speculatedTypeChecker)
    15031503{
    15041504    SpeculateCellOperand op1(this, node.child1());
    … …  
    15101510    GPRReg resultGPR = result.gpr();
    15111511   
    1512     if (!predictionCheck(m_state.forNode(node.child1()).m_type))
     1512    if (!speculatedTypeChecker(m_state.forNode(node.child1()).m_type))
    15131513        speculationCheck(BadType, JSValueRegs(op1GPR), node.child1().index(), m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(op1GPR, JSCell::classInfoOffset()), MacroAssembler::TrustedImmPtr(classInfo)));
    1514     if (!predictionCheck(m_state.forNode(node.child2()).m_type))
     1514    if (!speculatedTypeChecker(m_state.forNode(node.child2()).m_type))
    15151515        speculationCheck(BadType, JSValueRegs(op2GPR), node.child2().index(), m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(op2GPR, JSCell::classInfoOffset()), MacroAssembler::TrustedImmPtr(classInfo)));
    15161516   
    … …  
    15271527void SpeculativeJIT::compileObjectToObjectOrOtherEquality(
    15281528    Edge leftChild, Edge rightChild,
    1529     const ClassInfo* classInfo, PredictionChecker predictionCheck)
     1529    const ClassInfo* classInfo, SpeculatedTypeChecker speculatedTypeChecker)
    15301530{
    15311531    SpeculateCellOperand op1(this, leftChild);
    … …  
    15371537    GPRReg resultGPR = result.gpr();
    15381538   
    1539     if (!predictionCheck(m_state.forNode(leftChild).m_type)) {
     1539    if (!speculatedTypeChecker(m_state.forNode(leftChild).m_type)) {
    15401540        speculationCheck(
    15411541            BadType, JSValueRegs(op1GPR), leftChild.index(),
    … …  
    15531553    // We know that within this branch, rightChild must be a cell. If the CFA can tell us that the
    15541554    // proof, when filtered on cell, demonstrates that we have an object of the desired type
    1555     // (predictionCheck() will test for FinalObject or Array, currently), then we can skip the
     1555    // (speculationCheck() will test for FinalObject or Array, currently), then we can skip the
    15561556    // speculation.
    1557     if (!predictionCheck(m_state.forNode(rightChild).m_type & PredictCell)) {
     1557    if (!speculatedTypeChecker(m_state.forNode(rightChild).m_type & SpecCell)) {
    15581558        speculationCheck(
    15591559            BadType, JSValueRegs(op2GPR), rightChild.index(),
    … …  
    15741574    // We know that within this branch, rightChild must not be a cell. Check if that is enough to
    15751575    // prove that it is either null or undefined.
    1576     if (!isOtherPrediction(m_state.forNode(rightChild).m_type & ~PredictCell)) {
     1576    if (!isOtherSpeculation(m_state.forNode(rightChild).m_type & ~SpecCell)) {
    15771577        m_jit.move(op2GPR, resultGPR);
    15781578        m_jit.andPtr(MacroAssembler::TrustedImm32(~TagBitUndefined), resultGPR);
    … …  
    15971597void SpeculativeJIT::compilePeepHoleObjectToObjectOrOtherEquality(
    15981598    Edge leftChild, Edge rightChild, NodeIndex branchNodeIndex,
    1599     const ClassInfo* classInfo, PredictionChecker predictionCheck)
     1599    const ClassInfo* classInfo, SpeculatedTypeChecker speculatedTypeChecker)
    16001600{
    16011601    Node& branchNode = at(branchNodeIndex);
    … …  
    16111611    GPRReg resultGPR = result.gpr();
    16121612   
    1613     if (!predictionCheck(m_state.forNode(leftChild).m_type)) {
     1613    if (!speculatedTypeChecker(m_state.forNode(leftChild).m_type)) {
    16141614        speculationCheck(
    16151615            BadType, JSValueRegs(op1GPR), leftChild.index(),
    … …  
    16271627    // We know that within this branch, rightChild must be a cell. If the CFA can tell us that the
    16281628    // proof, when filtered on cell, demonstrates that we have an object of the desired type
    1629     // (predictionCheck() will test for FinalObject or Array, currently), then we can skip the
     1629    // (speculationCheck() will test for FinalObject or Array, currently), then we can skip the
    16301630    // speculation.
    1631     if (!predictionCheck(m_state.forNode(rightChild).m_type & PredictCell)) {
     1631    if (!speculatedTypeChecker(m_state.forNode(rightChild).m_type & SpecCell)) {
    16321632        speculationCheck(
    16331633            BadType, JSValueRegs(op2GPR), rightChild.index(),
    … …  
    16451645    // We know that within this branch, rightChild must not be a cell. Check if that is enough to
    16461646    // prove that it is either null or undefined.
    1647     if (isOtherPrediction(m_state.forNode(rightChild).m_type & ~PredictCell))
     1647    if (isOtherSpeculation(m_state.forNode(rightChild).m_type & ~SpecCell))
    16481648        rightNotCell.link(&m_jit);
    16491649    else {
    … …  
    17401740{
    17411741    if (at(node.child1()).shouldSpeculateFinalObjectOrOther()) {
    1742         compileObjectOrOtherLogicalNot(node.child1(), &JSFinalObject::s_info, !isFinalObjectOrOtherPrediction(m_state.forNode(node.child1()).m_type));
     1742        compileObjectOrOtherLogicalNot(node.child1(), &JSFinalObject::s_info, !isFinalObjectOrOtherSpeculation(m_state.forNode(node.child1()).m_type));
    17431743        return;
    17441744    }
    17451745    if (at(node.child1()).shouldSpeculateArrayOrOther()) {
    1746         compileObjectOrOtherLogicalNot(node.child1(), &JSArray::s_info, !isArrayOrOtherPrediction(m_state.forNode(node.child1()).m_type));
     1746        compileObjectOrOtherLogicalNot(node.child1(), &JSArray::s_info, !isArrayOrOtherSpeculation(m_state.forNode(node.child1()).m_type));
    17471747        return;
    17481748    }
    … …  
    17671767    }
    17681768   
    1769     PredictedType prediction = m_jit.getPrediction(node.child1());
    1770     if (isBooleanPrediction(prediction)) {
    1771         if (isBooleanPrediction(m_state.forNode(node.child1()).m_type)) {
     1769    SpeculatedType prediction = m_jit.getSpeculation(node.child1());
     1770    if (isBooleanSpeculation(prediction)) {
     1771        if (isBooleanSpeculation(m_state.forNode(node.child1()).m_type)) {
    17721772            SpeculateBooleanOperand value(this, node.child1());
    17731773            GPRTemporary result(this, value);
    … …  
    18421842   
    18431843    if (at(node.child1()).shouldSpeculateFinalObjectOrOther()) {
    1844         emitObjectOrOtherBranch(node.child1(), taken, notTaken, &JSFinalObject::s_info, !isFinalObjectOrOtherPrediction(m_state.forNode(node.child1()).m_type));
     1844        emitObjectOrOtherBranch(node.child1(), taken, notTaken, &JSFinalObject::s_info, !isFinalObjectOrOtherSpeculation(m_state.forNode(node.child1()).m_type));
    18451845    } else if (at(node.child1()).shouldSpeculateArrayOrOther()) {
    1846         emitObjectOrOtherBranch(node.child1(), taken, notTaken, &JSArray::s_info, !isArrayOrOtherPrediction(m_state.forNode(node.child1()).m_type));
     1846        emitObjectOrOtherBranch(node.child1(), taken, notTaken, &JSArray::s_info, !isArrayOrOtherSpeculation(m_state.forNode(node.child1()).m_type));
    18471847    } else if (at(node.child1()).shouldSpeculateNumber()) {
    18481848        if (at(node.child1()).shouldSpeculateInteger()) {
    … …  
    18711871        GPRReg valueGPR = value.gpr();
    18721872       
    1873         bool predictBoolean = isBooleanPrediction(m_jit.getPrediction(node.child1()));
     1873        bool predictBoolean = isBooleanSpeculation(m_jit.getSpeculation(node.child1()));
    18741874   
    18751875        if (predictBoolean) {
    1876             if (isBooleanPrediction(m_state.forNode(node.child1()).m_type)) {
     1876            if (isBooleanSpeculation(m_state.forNode(node.child1()).m_type)) {
    18771877                MacroAssembler::ResultCondition condition = MacroAssembler::NonZero;
    18781878               
    … …  
    19411941
    19421942    case GetLocal: {
    1943         PredictedType prediction = node.variableAccessData()->prediction();
     1943        SpeculatedType prediction = node.variableAccessData()->prediction();
    19441944        AbstractValue& value = block()->valuesAtHead.operand(node.local());
    19451945
    19461946        // If we have no prediction for this local, then don't attempt to compile.
    1947         if (prediction == PredictNone) {
     1947        if (prediction == SpecNone) {
    19481948            terminateSpeculativeExecution(InadequateCoverage, JSValueRegs(), NoNode);
    19491949            break;
    … …  
    19671967            }
    19681968           
    1969             if (isInt32Prediction(value.m_type)) {
     1969            if (isInt32Speculation(value.m_type)) {
    19701970                GPRTemporary result(this);
    19711971                m_jit.load32(JITCompiler::payloadFor(node.local()), result.gpr());
    … …  
    19911991        if (node.variableAccessData()->isCaptured())
    19921992            format = DataFormatJS;
    1993         else if (isCellPrediction(value.m_type))
     1993        else if (isCellSpeculation(value.m_type))
    19941994            format = DataFormatJSCell;
    1995         else if (isBooleanPrediction(value.m_type))
     1995        else if (isBooleanSpeculation(value.m_type))
    19961996            format = DataFormatJSBoolean;
    19971997        else
    … …  
    20602060            }
    20612061       
    2062             PredictedType predictedType = node.variableAccessData()->argumentAwarePrediction();
    2063             if (isInt32Prediction(predictedType)) {
     2062            SpeculatedType predictedType = node.variableAccessData()->argumentAwarePrediction();
     2063            if (isInt32Speculation(predictedType)) {
    20642064                SpeculateIntegerOperand value(this, node.child1());
    20652065                m_jit.store32(value.gpr(), JITCompiler::payloadFor(node.local()));
    … …  
    20682068                break;
    20692069            }
    2070             if (isArrayPrediction(predictedType)) {
     2070            if (isArraySpeculation(predictedType)) {
    20712071                SpeculateCellOperand cell(this, node.child1());
    20722072                GPRReg cellGPR = cell.gpr();
    2073                 if (!isArrayPrediction(m_state.forNode(node.child1()).m_type))
     2073                if (!isArraySpeculation(m_state.forNode(node.child1()).m_type))
    20742074                    speculationCheck(BadType, JSValueRegs(cellGPR), node.child1(), m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(cellGPR, JSCell::classInfoOffset()), MacroAssembler::TrustedImmPtr(&JSArray::s_info)));
    20752075                m_jit.storePtr(cellGPR, JITCompiler::addressFor(node.local()));
    … …  
    20782078                break;
    20792079            }
    2080             if (isBooleanPrediction(predictedType)) {
     2080            if (isBooleanSpeculation(predictedType)) {
    20812081                SpeculateBooleanOperand boolean(this, node.child1());
    20822082                m_jit.storePtr(boolean.gpr(), JITCompiler::addressFor(node.local()));
    … …  
    21772177       
    21782178    case CheckNumber: {
    2179         if (!isNumberPrediction(m_state.forNode(node.child1()).m_type)) {
     2179        if (!isNumberSpeculation(m_state.forNode(node.child1()).m_type)) {
    21802180            JSValueOperand op1(this, node.child1());
    21812181            JITCompiler::Jump isInteger = m_jit.branchPtr(MacroAssembler::AboveOrEqual, op1.gpr(), GPRInfo::tagTypeNumberRegister);
    … …  
    23772377        }
    23782378       
    2379         if (!at(node.child2()).shouldSpeculateInteger() || !isActionableArrayPrediction(at(node.child1()).prediction())) {
     2379        if (!at(node.child2()).shouldSpeculateInteger() || !isActionableArraySpeculation(at(node.child1()).prediction())) {
    23802380            JSValueOperand base(this, node.child1());
    23812381            JSValueOperand property(this, node.child2());
    … …  
    23982398        }
    23992399       
    2400         if (at(node.child1()).prediction() == PredictString) {
     2400        if (at(node.child1()).prediction() == SpecString) {
    24012401            compileGetByValOnString(node);
    24022402            if (!m_compileOkay)
    … …  
    24062406
    24072407        if (at(node.child1()).shouldSpeculateInt8Array()) {
    2408             compileGetByValOnIntTypedArray(m_jit.globalData()->int8ArrayDescriptor(), node, sizeof(int8_t), isInt8ArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, SignedTypedArray);
     2408            compileGetByValOnIntTypedArray(m_jit.globalData()->int8ArrayDescriptor(), node, sizeof(int8_t), isInt8ArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, SignedTypedArray);
    24092409            if (!m_compileOkay)
    24102410                return;
    … …  
    24132413       
    24142414        if (at(node.child1()).shouldSpeculateInt16Array()) {
    2415             compileGetByValOnIntTypedArray(m_jit.globalData()->int16ArrayDescriptor(), node, sizeof(int16_t), isInt16ArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, SignedTypedArray);
     2415            compileGetByValOnIntTypedArray(m_jit.globalData()->int16ArrayDescriptor(), node, sizeof(int16_t), isInt16ArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, SignedTypedArray);
    24162416            if (!m_compileOkay)
    24172417                return;
    … …  
    24202420       
    24212421        if (at(node.child1()).shouldSpeculateInt32Array()) {
    2422             compileGetByValOnIntTypedArray(m_jit.globalData()->int32ArrayDescriptor(), node, sizeof(int32_t), isInt32ArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, SignedTypedArray);
     2422            compileGetByValOnIntTypedArray(m_jit.globalData()->int32ArrayDescriptor(), node, sizeof(int32_t), isInt32ArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, SignedTypedArray);
    24232423            if (!m_compileOkay)
    24242424                return;
    … …  
    24272427
    24282428        if (at(node.child1()).shouldSpeculateUint8Array()) {
    2429             compileGetByValOnIntTypedArray(m_jit.globalData()->uint8ArrayDescriptor(), node, sizeof(uint8_t), isUint8ArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, UnsignedTypedArray);
     2429            compileGetByValOnIntTypedArray(m_jit.globalData()->uint8ArrayDescriptor(), node, sizeof(uint8_t), isUint8ArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, UnsignedTypedArray);
    24302430            if (!m_compileOkay)
    24312431                return;
    … …  
    24342434
    24352435        if (at(node.child1()).shouldSpeculateUint8ClampedArray()) {
    2436             compileGetByValOnIntTypedArray(m_jit.globalData()->uint8ClampedArrayDescriptor(), node, sizeof(uint8_t), isUint8ClampedArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, UnsignedTypedArray);
     2436            compileGetByValOnIntTypedArray(m_jit.globalData()->uint8ClampedArrayDescriptor(), node, sizeof(uint8_t), isUint8ClampedArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, UnsignedTypedArray);
    24372437            if (!m_compileOkay)
    24382438                return;
    … …  
    24412441
    24422442        if (at(node.child1()).shouldSpeculateUint16Array()) {
    2443             compileGetByValOnIntTypedArray(m_jit.globalData()->uint16ArrayDescriptor(), node, sizeof(uint16_t), isUint16ArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, UnsignedTypedArray);
     2443            compileGetByValOnIntTypedArray(m_jit.globalData()->uint16ArrayDescriptor(), node, sizeof(uint16_t), isUint16ArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, UnsignedTypedArray);
    24442444            if (!m_compileOkay)
    24452445                return;
    … …  
    24482448       
    24492449        if (at(node.child1()).shouldSpeculateUint32Array()) {
    2450             compileGetByValOnIntTypedArray(m_jit.globalData()->uint32ArrayDescriptor(), node, sizeof(uint32_t), isUint32ArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, UnsignedTypedArray);
     2450            compileGetByValOnIntTypedArray(m_jit.globalData()->uint32ArrayDescriptor(), node, sizeof(uint32_t), isUint32ArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, UnsignedTypedArray);
    24512451            if (!m_compileOkay)
    24522452                return;
    … …  
    24552455       
    24562456        if (at(node.child1()).shouldSpeculateFloat32Array()) {
    2457             compileGetByValOnFloatTypedArray(m_jit.globalData()->float32ArrayDescriptor(), node, sizeof(float), isFloat32ArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks);
     2457            compileGetByValOnFloatTypedArray(m_jit.globalData()->float32ArrayDescriptor(), node, sizeof(float), isFloat32ArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks);
    24582458            if (!m_compileOkay)
    24592459                return;
    … …  
    24622462       
    24632463        if (at(node.child1()).shouldSpeculateFloat64Array()) {
    2464             compileGetByValOnFloatTypedArray(m_jit.globalData()->float64ArrayDescriptor(), node, sizeof(double), isFloat64ArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks);
     2464            compileGetByValOnFloatTypedArray(m_jit.globalData()->float64ArrayDescriptor(), node, sizeof(double), isFloat64ArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks);
    24652465            if (!m_compileOkay)
    24662466                return;
    … …  
    24812481            return;
    24822482
    2483         if (!isArrayPrediction(m_state.forNode(node.child1()).m_type))
     2483        if (!isArraySpeculation(m_state.forNode(node.child1()).m_type))
    24842484            speculationCheck(BadType, JSValueRegs(baseReg), node.child1(), m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(baseReg, JSCell::classInfoOffset()), MacroAssembler::TrustedImmPtr(&JSArray::s_info)));
    24852485        speculationCheck(Uncountable, JSValueRegs(), NoNode, m_jit.branch32(MacroAssembler::AboveOrEqual, propertyReg, MacroAssembler::Address(baseReg, JSArray::vectorLengthOffset())));
    … …  
    25022502        }
    25032503       
    2504         if (!at(node.child2()).shouldSpeculateInteger() || !isActionableMutableArrayPrediction(at(node.child1()).prediction())) {
     2504        if (!at(node.child2()).shouldSpeculateInteger() || !isActionableMutableArraySpeculation(at(node.child1()).prediction())) {
    25052505            JSValueOperand arg1(this, node.child1());
    25062506            JSValueOperand arg2(this, node.child2());
    … …  
    25352535                return;
    25362536
    2537             if (!isArgumentsPrediction(m_state.forNode(node.child1()).m_type)) {
     2537            if (!isArgumentsSpeculation(m_state.forNode(node.child1()).m_type)) {
    25382538                speculationCheck(
    25392539                    BadType, JSValueSource::unboxedCell(baseReg), node.child1(),
    … …  
    25792579       
    25802580        if (at(node.child1()).shouldSpeculateInt8Array()) {
    2581             compilePutByValForIntTypedArray(m_jit.globalData()->int8ArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(int8_t), isInt8ArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, SignedTypedArray);
     2581            compilePutByValForIntTypedArray(m_jit.globalData()->int8ArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(int8_t), isInt8ArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, SignedTypedArray);
    25822582            if (!m_compileOkay)
    25832583                return;
    … …  
    25862586       
    25872587        if (at(node.child1()).shouldSpeculateInt16Array()) {
    2588             compilePutByValForIntTypedArray(m_jit.globalData()->int16ArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(int16_t), isInt16ArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, SignedTypedArray);
     2588            compilePutByValForIntTypedArray(m_jit.globalData()->int16ArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(int16_t), isInt16ArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, SignedTypedArray);
    25892589            if (!m_compileOkay)
    25902590                return;
    … …  
    25932593
    25942594        if (at(node.child1()).shouldSpeculateInt32Array()) {
    2595             compilePutByValForIntTypedArray(m_jit.globalData()->int32ArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(int32_t), isInt32ArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, SignedTypedArray);
     2595            compilePutByValForIntTypedArray(m_jit.globalData()->int32ArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(int32_t), isInt32ArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, SignedTypedArray);
    25962596            if (!m_compileOkay)
    25972597                return;
    … …  
    26002600       
    26012601        if (at(node.child1()).shouldSpeculateUint8Array()) {
    2602             compilePutByValForIntTypedArray(m_jit.globalData()->uint8ArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(uint8_t), isUint8ArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, UnsignedTypedArray);
     2602            compilePutByValForIntTypedArray(m_jit.globalData()->uint8ArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(uint8_t), isUint8ArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, UnsignedTypedArray);
    26032603            if (!m_compileOkay)
    26042604                return;
    … …  
    26072607
    26082608        if (at(node.child1()).shouldSpeculateUint8ClampedArray()) {
    2609             compilePutByValForIntTypedArray(m_jit.globalData()->uint8ClampedArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(uint8_t), isUint8ClampedArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, UnsignedTypedArray, ClampRounding);
     2609            compilePutByValForIntTypedArray(m_jit.globalData()->uint8ClampedArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(uint8_t), isUint8ClampedArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, UnsignedTypedArray, ClampRounding);
    26102610            break;
    26112611        }
    26122612
    26132613        if (at(node.child1()).shouldSpeculateUint16Array()) {
    2614             compilePutByValForIntTypedArray(m_jit.globalData()->uint16ArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(uint16_t), isUint16ArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, UnsignedTypedArray);
     2614            compilePutByValForIntTypedArray(m_jit.globalData()->uint16ArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(uint16_t), isUint16ArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, UnsignedTypedArray);
    26152615            if (!m_compileOkay)
    26162616                return;
    … …  
    26192619       
    26202620        if (at(node.child1()).shouldSpeculateUint32Array()) {
    2621             compilePutByValForIntTypedArray(m_jit.globalData()->uint32ArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(uint32_t), isUint32ArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, UnsignedTypedArray);
     2621            compilePutByValForIntTypedArray(m_jit.globalData()->uint32ArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(uint32_t), isUint32ArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks, UnsignedTypedArray);
    26222622            if (!m_compileOkay)
    26232623                return;
    … …  
    26262626       
    26272627        if (at(node.child1()).shouldSpeculateFloat32Array()) {
    2628             compilePutByValForFloatTypedArray(m_jit.globalData()->float32ArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(float), isFloat32ArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks);
     2628            compilePutByValForFloatTypedArray(m_jit.globalData()->float32ArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(float), isFloat32ArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks);
    26292629            if (!m_compileOkay)
    26302630                return;
    … …  
    26332633       
    26342634        if (at(node.child1()).shouldSpeculateFloat64Array()) {
    2635             compilePutByValForFloatTypedArray(m_jit.globalData()->float64ArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(double), isFloat64ArrayPrediction(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks);
     2635            compilePutByValForFloatTypedArray(m_jit.globalData()->float64ArrayDescriptor(), base.gpr(), property.gpr(), node, sizeof(double), isFloat64ArraySpeculation(m_state.forNode(node.child1()).m_type) ? NoTypedArrayTypeSpecCheck : AllTypedArraySpecChecks);
    26362636            if (!m_compileOkay)
    26372637                return;
    … …  
    26572657        // Check that base is an array, and that property is contained within m_vector (< m_vectorLength).
    26582658        // If we have predicted the base to be type array, we can skip the check.
    2659         if (!isArrayPrediction(m_state.forNode(node.child1()).m_type))
     2659        if (!isArraySpeculation(m_state.forNode(node.child1()).m_type))
    26602660            speculationCheck(BadType, JSValueRegs(baseReg), node.child1(), m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(baseReg, JSCell::classInfoOffset()), MacroAssembler::TrustedImmPtr(&JSArray::s_info)));
    26612661
    … …  
    27022702        }
    27032703       
    2704         ASSERT(isActionableMutableArrayPrediction(at(node.child1()).prediction()));
     2704        ASSERT(isActionableMutableArraySpeculation(at(node.child1()).prediction()));
    27052705        ASSERT(at(node.child2()).shouldSpeculateInteger());
    27062706
    … …  
    28542854        writeBarrier(baseGPR, valueGPR, node.child2(), WriteBarrierForPropertyAccess, storageGPR, storageLengthGPR);
    28552855
    2856         if (!isArrayPrediction(m_state.forNode(node.child1()).m_type))
     2856        if (!isArraySpeculation(m_state.forNode(node.child1()).m_type))
    28572857            speculationCheck(BadType, JSValueRegs(baseGPR), node.child1(), m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(baseGPR, JSCell::classInfoOffset()), MacroAssembler::TrustedImmPtr(&JSArray::s_info)));
    28582858       
    … …  
    28922892        GPRReg storageLengthGPR = storageLength.gpr();
    28932893       
    2894         if (!isArrayPrediction(m_state.forNode(node.child1()).m_type))
     2894        if (!isArraySpeculation(m_state.forNode(node.child1()).m_type))
    28952895            speculationCheck(BadType, JSValueRegs(baseGPR), node.child1(), m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(baseGPR, JSCell::classInfoOffset()), MacroAssembler::TrustedImmPtr(&JSArray::s_info)));
    28962896       
    … …  
    30193019        op1.use();
    30203020       
    3021         if (!(m_state.forNode(node.child1()).m_type & ~(PredictNumber | PredictBoolean)))
     3021        if (!(m_state.forNode(node.child1()).m_type & ~(SpecNumber | SpecBoolean)))
    30223022            m_jit.move(op1GPR, resultGPR);
    30233023        else {
    … …  
    31133113       
    31143114    case ConvertThis: {
    3115         if (isObjectPrediction(m_state.forNode(node.child1()).m_type)) {
     3115        if (isObjectSpeculation(m_state.forNode(node.child1()).m_type)) {
    31163116            SpeculateCellOperand thisValue(this, node.child1());
    31173117            GPRTemporary result(this, thisValue);
    … …  
    31213121        }
    31223122       
    3123         if (isOtherPrediction(at(node.child1()).prediction())) {
     3123        if (isOtherSpeculation(at(node.child1()).prediction())) {
    31243124            JSValueOperand thisValue(this, node.child1());
    31253125            GPRTemporary scratch(this, thisValue);
    … …  
    31273127            GPRReg scratchGPR = scratch.gpr();
    31283128           
    3129             if (!isOtherPrediction(m_state.forNode(node.child1()).m_type)) {
     3129            if (!isOtherSpeculation(m_state.forNode(node.child1()).m_type)) {
    31303130                m_jit.move(thisValueGPR, scratchGPR);
    31313131                m_jit.andPtr(MacroAssembler::TrustedImm32(~TagBitUndefined), scratchGPR);
    … …  
    31383138        }
    31393139       
    3140         if (isObjectPrediction(at(node.child1()).prediction())) {
     3140        if (isObjectSpeculation(at(node.child1()).prediction())) {
    31413141            SpeculateCellOperand thisValue(this, node.child1());
    31423142            GPRTemporary result(this, thisValue);
    … …  
    31443144            GPRReg resultGPR = result.gpr();
    31453145           
    3146             if (!isObjectPrediction(m_state.forNode(node.child1()).m_type))
     3146            if (!isObjectSpeculation(m_state.forNode(node.child1()).m_type))
    31473147                speculationCheck(BadType, JSValueRegs(thisValueGPR), node.child1(), m_jit.branchPtr(JITCompiler::Equal, JITCompiler::Address(thisValueGPR, JSCell::classInfoOffset()), JITCompiler::TrustedImmPtr(&JSString::s_info)));
    31483148           
    … …  
    32663266        }
    32673267       
    3268         if (isCellPrediction(at(node.child1()).prediction())) {
     3268        if (isCellSpeculation(at(node.child1()).prediction())) {
    32693269            SpeculateCellOperand base(this, node.child1());
    32703270            GPRTemporary result(this, base);
    … …  
    33163316        }
    33173317       
    3318         if (isCellPrediction(at(node.child1()).prediction())) {
     3318        if (isCellSpeculation(at(node.child1()).prediction())) {
    33193319            SpeculateCellOperand base(this, node.child1());
    33203320            GPRReg baseGPR = base.gpr();
    … …  
    33633363        GPRReg resultGPR = result.gpr();
    33643364       
    3365         if (!isArrayPrediction(m_state.forNode(node.child1()).m_type))
     3365        if (!isArraySpeculation(m_state.forNode(node.child1()).m_type))
    33663366            speculationCheck(BadType, JSValueRegs(baseGPR), node.child1(), m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(baseGPR, JSCell::classInfoOffset()), MacroAssembler::TrustedImmPtr(&JSArray::s_info)));
    33673367       
    … …  
    33873387        GPRReg resultGPR = result.gpr();
    33883388       
    3389         if (!isStringPrediction(m_state.forNode(node.child1()).m_type))
     3389        if (!isStringSpeculation(m_state.forNode(node.child1()).m_type))
    33903390            speculationCheck(BadType, JSValueRegs(baseGPR), node.child1(), m_jit.branchPtr(MacroAssembler::NotEqual, MacroAssembler::Address(baseGPR, JSCell::classInfoOffset()), MacroAssembler::TrustedImmPtr(&JSString::s_info)));
    33913391       
    … …  
    33973397
    33983398    case GetInt8ArrayLength: {
    3399         compileGetTypedArrayLength(m_jit.globalData()->int8ArrayDescriptor(), node, !isInt8ArrayPrediction(m_state.forNode(node.child1()).m_type));
     3399        compileGetTypedArrayLength(m_jit.globalData()->int8ArrayDescriptor(), node, !isInt8ArraySpeculation(m_state.forNode(node.child1()).m_type));
    34003400        break;
    34013401    }
    34023402    case GetInt16ArrayLength: {
    3403         compileGetTypedArrayLength(m_jit.globalData()->int16ArrayDescriptor(), node, !isInt16ArrayPrediction(m_state.forNode(node.child1()).m_type));
     3403        compileGetTypedArrayLength(m_jit.globalData()->int16ArrayDescriptor(), node, !isInt16ArraySpeculation(m_state.forNode(node.child1()).m_type));
    34043404        break;
    34053405    }
    34063406    case GetInt32ArrayLength: {
    3407         compileGetTypedArrayLength(m_jit.globalData()->int32ArrayDescriptor(), node, !isInt32ArrayPrediction(m_state.forNode(node.child1()).m_type));
     3407        compileGetTypedArrayLength(m_jit.globalData()->int32ArrayDescriptor(), node, !isInt32ArraySpeculation(m_state.forNode(node.child1()).m_type));
    34083408        break;
    34093409    }
    34103410    case GetUint8ArrayLength: {
    3411         compileGetTypedArrayLength(m_jit.globalData()->uint8ArrayDescriptor(), node, !isUint8ArrayPrediction(m_state.forNode(node.child1()).m_type));
     3411        compileGetTypedArrayLength(m_jit.globalData()->uint8ArrayDescriptor(), node, !isUint8ArraySpeculation(m_state.forNode(node.child1()).m_type));
    34123412        break;
    34133413    }
    34143414    case GetUint8ClampedArrayLength: {
    3415         compileGetTypedArrayLength(m_jit.globalData()->uint8ClampedArrayDescriptor(), node, !isUint8ClampedArrayPrediction(m_state.forNode(node.child1()).m_type));
     3415        compileGetTypedArrayLength(m_jit.globalData()->uint8ClampedArrayDescriptor(), node, !isUint8ClampedArraySpeculation(m_state.forNode(node.child1()).m_type));
    34163416        break;
    34173417    }
    34183418    case GetUint16ArrayLength: {
    3419         compileGetTypedArrayLength(m_jit.globalData()->uint16ArrayDescriptor(), node, !isUint16ArrayPrediction(m_state.forNode(node.child1()).m_type));
     3419        compileGetTypedArrayLength(m_jit.globalData()->uint16ArrayDescriptor(), node, !isUint16ArraySpeculation(m_state.forNode(node.child1()).m_type));
    34203420        break;
    34213421    }
    34223422    case GetUint32ArrayLength: {
    3423         compileGetTypedArrayLength(m_jit.globalData()->uint32ArrayDescriptor(), node, !isUint32ArrayPrediction(m_state.forNode(node.child1()).m_type));
     3423        compileGetTypedArrayLength(m_jit.globalData()->uint32ArrayDescriptor(), node, !isUint32ArraySpeculation(m_state.forNode(node.child1()).m_type));
    34243424        break;
    34253425    }
    34263426    case GetFloat32ArrayLength: {
    3427         compileGetTypedArrayLength(m_jit.globalData()->float32ArrayDescriptor(), node, !isFloat32ArrayPrediction(m_state.forNode(node.child1()).m_type));
     3427        compileGetTypedArrayLength(m_jit.globalData()->float32ArrayDescriptor(), node, !isFloat32ArraySpeculation(m_state.forNode(node.child1()).m_type));
    34283428        break;
    34293429    }
    34303430    case GetFloat64ArrayLength: {
    3431         compileGetTypedArrayLength(m_jit.globalData()->float64ArrayDescriptor(), node, !isFloat64ArrayPrediction(m_state.forNode(node.child1()).m_type));
     3431        compileGetTypedArrayLength(m_jit.globalData()->float64ArrayDescriptor(), node, !isFloat64ArraySpeculation(m_state.forNode(node.child1()).m_type));
    34323432        break;
    34333433    }
    … …  
    34413441        AbstractValue& value = m_state.forNode(node.child1());
    34423442        if (value.m_structure.isSubsetOf(node.structureSet())
    3443             && isCellPrediction(value.m_type)) {
     3443            && isCellSpeculation(value.m_type)) {
    34443444            noResult(m_compileIndex);
    34453445            break;
    … …  
    38823882        GPRReg resultGPR = result.gpr();
    38833883       
    3884         if (!isEmptyPrediction(
     3884        if (!isEmptySpeculation(
    38853885                m_state.variables().operand(
    38863886                    m_jit.graph().argumentsRegisterFor(node.codeOrigin)).m_type)) {
    … …  
    39413941        GPRReg resultGPR = result.gpr();
    39423942       
    3943         if (!isEmptyPrediction(
     3943        if (!isEmptySpeculation(
    39443944                m_state.variables().operand(
    39453945                    m_jit.graph().argumentsRegisterFor(node.codeOrigin)).m_type)) {
    … …  
    40434043       
    40444044    case CheckArgumentsNotCreated: {
    4045         ASSERT(!isEmptyPrediction(
     4045        ASSERT(!isEmptySpeculation(
    40464046            m_state.variables().operand(
    40474047                m_jit.graph().argumentsRegisterFor(node.codeOrigin)).m_type));
Note: See TracChangeset for help on using the changeset viewer.