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/DFGAbstractState.cpp

    r119342 r119660  
    100100        }
    101101       
    102         PredictedType prediction = node.variableAccessData()->prediction();
    103         if (isInt32Prediction(prediction))
    104             root->valuesAtHead.argument(i).set(PredictInt32);
    105         else if (isArrayPrediction(prediction))
    106             root->valuesAtHead.argument(i).set(PredictArray);
    107         else if (isBooleanPrediction(prediction))
    108             root->valuesAtHead.argument(i).set(PredictBoolean);
    109         else if (isInt8ArrayPrediction(prediction))
    110             root->valuesAtHead.argument(i).set(PredictInt8Array);
    111         else if (isInt16ArrayPrediction(prediction))
    112             root->valuesAtHead.argument(i).set(PredictInt16Array);
    113         else if (isInt32ArrayPrediction(prediction))
    114             root->valuesAtHead.argument(i).set(PredictInt32Array);
    115         else if (isUint8ArrayPrediction(prediction))
    116             root->valuesAtHead.argument(i).set(PredictUint8Array);
    117         else if (isUint8ClampedArrayPrediction(prediction))
    118             root->valuesAtHead.argument(i).set(PredictUint8ClampedArray);
    119         else if (isUint16ArrayPrediction(prediction))
    120             root->valuesAtHead.argument(i).set(PredictUint16Array);
    121         else if (isUint32ArrayPrediction(prediction))
    122             root->valuesAtHead.argument(i).set(PredictUint32Array);
    123         else if (isFloat32ArrayPrediction(prediction))
    124             root->valuesAtHead.argument(i).set(PredictFloat32Array);
    125         else if (isFloat64ArrayPrediction(prediction))
    126             root->valuesAtHead.argument(i).set(PredictFloat64Array);
     102        SpeculatedType prediction = node.variableAccessData()->prediction();
     103        if (isInt32Speculation(prediction))
     104            root->valuesAtHead.argument(i).set(SpecInt32);
     105        else if (isArraySpeculation(prediction))
     106            root->valuesAtHead.argument(i).set(SpecArray);
     107        else if (isBooleanSpeculation(prediction))
     108            root->valuesAtHead.argument(i).set(SpecBoolean);
     109        else if (isInt8ArraySpeculation(prediction))
     110            root->valuesAtHead.argument(i).set(SpecInt8Array);
     111        else if (isInt16ArraySpeculation(prediction))
     112            root->valuesAtHead.argument(i).set(SpecInt16Array);
     113        else if (isInt32ArraySpeculation(prediction))
     114            root->valuesAtHead.argument(i).set(SpecInt32Array);
     115        else if (isUint8ArraySpeculation(prediction))
     116            root->valuesAtHead.argument(i).set(SpecUint8Array);
     117        else if (isUint8ClampedArraySpeculation(prediction))
     118            root->valuesAtHead.argument(i).set(SpecUint8ClampedArray);
     119        else if (isUint16ArraySpeculation(prediction))
     120            root->valuesAtHead.argument(i).set(SpecUint16Array);
     121        else if (isUint32ArraySpeculation(prediction))
     122            root->valuesAtHead.argument(i).set(SpecUint32Array);
     123        else if (isFloat32ArraySpeculation(prediction))
     124            root->valuesAtHead.argument(i).set(SpecFloat32Array);
     125        else if (isFloat64ArraySpeculation(prediction))
     126            root->valuesAtHead.argument(i).set(SpecFloat64Array);
    127127        else
    128128            root->valuesAtHead.argument(i).makeTop();
     
    239239        VariableAccessData* variableAccessData = node.variableAccessData();
    240240        bool canExit = false;
    241         canExit |= variableAccessData->prediction() == PredictNone;
     241        canExit |= variableAccessData->prediction() == SpecNone;
    242242        AbstractValue value = m_variables.operand(variableAccessData->local());
    243243        if (!variableAccessData->isCaptured()) {
     
    270270        if (node.variableAccessData()->shouldUseDoubleFormat()) {
    271271            speculateNumberUnary(node);
    272             m_variables.operand(node.local()).set(PredictDouble);
    273             break;
    274         }
    275        
    276         PredictedType predictedType = node.variableAccessData()->argumentAwarePrediction();
    277         if (isInt32Prediction(predictedType))
     272            m_variables.operand(node.local()).set(SpecDouble);
     273            break;
     274        }
     275       
     276        SpeculatedType predictedType = node.variableAccessData()->argumentAwarePrediction();
     277        if (isInt32Speculation(predictedType))
    278278            speculateInt32Unary(node);
    279         else if (isArrayPrediction(predictedType)) {
    280             node.setCanExit(!isArrayPrediction(forNode(node.child1()).m_type));
    281             forNode(node.child1()).filter(PredictArray);
    282         } else if (isBooleanPrediction(predictedType))
     279        else if (isArraySpeculation(predictedType)) {
     280            node.setCanExit(!isArraySpeculation(forNode(node.child1()).m_type));
     281            forNode(node.child1()).filter(SpecArray);
     282        } else if (isBooleanSpeculation(predictedType))
    283283            speculateBooleanUnary(node);
    284284        else
     
    333333        }
    334334        speculateInt32Binary(node);
    335         forNode(nodeIndex).set(PredictInt32);
     335        forNode(nodeIndex).set(SpecInt32);
    336336        break;
    337337    }
     
    347347        }
    348348        if (!node.canSpeculateInteger()) {
    349             forNode(nodeIndex).set(PredictDouble);
     349            forNode(nodeIndex).set(SpecDouble);
    350350            node.setCanExit(false);
    351351        } else {
    352             forNode(nodeIndex).set(PredictInt32);
     352            forNode(nodeIndex).set(SpecInt32);
    353353            node.setCanExit(true);
    354354        }
     
    369369        }
    370370        node.setCanExit(true);
    371         forNode(node.child1()).filter(PredictNumber);
    372         forNode(nodeIndex).set(PredictInt32);
     371        forNode(node.child1()).filter(SpecNumber);
     372        forNode(nodeIndex).set(SpecInt32);
    373373        break;
    374374    }
     
    394394            node.setCanExit(false);
    395395       
    396         forNode(nodeIndex).set(PredictInt32);
     396        forNode(nodeIndex).set(SpecInt32);
    397397        break;
    398398    }
     
    407407        }
    408408        speculateNumberUnary(node);
    409         forNode(nodeIndex).set(PredictDouble);
     409        forNode(nodeIndex).set(SpecDouble);
    410410        break;
    411411    }
    412412       
    413413    case CheckNumber:
    414         forNode(node.child1()).filter(PredictNumber);
     414        forNode(node.child1()).filter(SpecNumber);
    415415        break;
    416416           
     
    428428            speculateInt32Binary(
    429429                node, !nodeCanTruncateInteger(node.arithNodeFlags()));
    430             forNode(nodeIndex).set(PredictInt32);
     430            forNode(nodeIndex).set(SpecInt32);
    431431            break;
    432432        }
    433433        if (Node::shouldSpeculateNumber(m_graph[node.child1()], m_graph[node.child2()])) {
    434434            speculateNumberBinary(node);
    435             forNode(nodeIndex).set(PredictDouble);
     435            forNode(nodeIndex).set(SpecDouble);
    436436            break;
    437437        }
    438438        if (node.op() == ValueAdd) {
    439439            clobberWorld(node.codeOrigin, indexInBlock);
    440             forNode(nodeIndex).set(PredictString | PredictInt32 | PredictNumber);
     440            forNode(nodeIndex).set(SpecString | SpecInt32 | SpecNumber);
    441441            node.setCanExit(false);
    442442            break;
     
    460460            speculateInt32Binary(
    461461                node, !nodeCanTruncateInteger(node.arithNodeFlags()));
    462             forNode(nodeIndex).set(PredictInt32);
     462            forNode(nodeIndex).set(SpecInt32);
    463463            break;
    464464        }
    465465        speculateNumberBinary(node);
    466         forNode(nodeIndex).set(PredictDouble);
     466        forNode(nodeIndex).set(SpecDouble);
    467467        break;
    468468    }
     
    479479            speculateInt32Unary(
    480480                node, !nodeCanTruncateInteger(node.arithNodeFlags()));
    481             forNode(nodeIndex).set(PredictInt32);
     481            forNode(nodeIndex).set(SpecInt32);
    482482            break;
    483483        }
    484484        speculateNumberUnary(node);
    485         forNode(nodeIndex).set(PredictDouble);
     485        forNode(nodeIndex).set(SpecDouble);
    486486        break;
    487487    }
     
    501501                !nodeCanTruncateInteger(node.arithNodeFlags())
    502502                || !nodeCanIgnoreNegativeZero(node.arithNodeFlags()));
    503             forNode(nodeIndex).set(PredictInt32);
     503            forNode(nodeIndex).set(SpecInt32);
    504504            break;
    505505        }
    506506        speculateNumberBinary(node);
    507         forNode(nodeIndex).set(PredictDouble);
     507        forNode(nodeIndex).set(SpecDouble);
    508508        break;
    509509    }
     
    543543            && node.canSpeculateInteger()) {
    544544            speculateInt32Binary(node, true); // forcing can-exit, which is a bit on the conservative side.
    545             forNode(nodeIndex).set(PredictInt32);
     545            forNode(nodeIndex).set(SpecInt32);
    546546            break;
    547547        }
    548548        speculateNumberBinary(node);
    549         forNode(nodeIndex).set(PredictDouble);
     549        forNode(nodeIndex).set(SpecDouble);
    550550        break;
    551551    }
     
    562562            && node.canSpeculateInteger()) {
    563563            speculateInt32Unary(node, true);
    564             forNode(nodeIndex).set(PredictInt32);
     564            forNode(nodeIndex).set(SpecInt32);
    565565            break;
    566566        }
    567567        speculateNumberUnary(node);
    568         forNode(nodeIndex).set(PredictDouble);
     568        forNode(nodeIndex).set(SpecDouble);
    569569        break;
    570570    }
     
    579579        }
    580580        speculateNumberUnary(node);
    581         forNode(nodeIndex).set(PredictDouble);
     581        forNode(nodeIndex).set(SpecDouble);
    582582        break;
    583583    }
     
    591591        }
    592592        Node& child = m_graph[node.child1()];
    593         if (isBooleanPrediction(child.prediction()))
     593        if (isBooleanSpeculation(child.prediction()))
    594594            speculateBooleanUnary(node);
    595595        else if (child.shouldSpeculateFinalObjectOrOther()) {
    596596            node.setCanExit(
    597                 !isFinalObjectOrOtherPrediction(forNode(node.child1()).m_type));
    598             forNode(node.child1()).filter(PredictFinalObject | PredictOther);
     597                !isFinalObjectOrOtherSpeculation(forNode(node.child1()).m_type));
     598            forNode(node.child1()).filter(SpecFinalObject | SpecOther);
    599599        } else if (child.shouldSpeculateArrayOrOther()) {
    600600            node.setCanExit(
    601                 !isArrayOrOtherPrediction(forNode(node.child1()).m_type));
    602             forNode(node.child1()).filter(PredictArray | PredictOther);
     601                !isArrayOrOtherSpeculation(forNode(node.child1()).m_type));
     602            forNode(node.child1()).filter(SpecArray | SpecOther);
    603603        } else if (child.shouldSpeculateInteger())
    604604            speculateInt32Unary(node);
     
    607607        else
    608608            node.setCanExit(false);
    609         forNode(nodeIndex).set(PredictBoolean);
     609        forNode(nodeIndex).set(SpecBoolean);
    610610        break;
    611611    }
     
    645645            }
    646646        }
    647         forNode(nodeIndex).set(PredictBoolean);
     647        forNode(nodeIndex).set(SpecBoolean);
    648648        break;
    649649    }
     
    684684        }
    685685       
    686         forNode(nodeIndex).set(PredictBoolean);
     686        forNode(nodeIndex).set(SpecBoolean);
    687687       
    688688        Node& left = m_graph[node.child1()];
    689689        Node& right = m_graph[node.child2()];
    690         PredictedType filter;
    691         PredictionChecker checker;
     690        SpeculatedType filter;
     691        SpeculatedTypeChecker checker;
    692692        if (Node::shouldSpeculateInteger(left, right)) {
    693             filter = PredictInt32;
    694             checker = isInt32Prediction;
     693            filter = SpecInt32;
     694            checker = isInt32Speculation;
    695695        } else if (Node::shouldSpeculateNumber(left, right)) {
    696             filter = PredictNumber;
    697             checker = isNumberPrediction;
     696            filter = SpecNumber;
     697            checker = isNumberSpeculation;
    698698        } else if (node.op() == CompareEq) {
    699699            if ((m_graph.isConstant(node.child1().index())
     
    707707           
    708708            if (Node::shouldSpeculateFinalObject(left, right)) {
    709                 filter = PredictFinalObject;
    710                 checker = isFinalObjectPrediction;
     709                filter = SpecFinalObject;
     710                checker = isFinalObjectSpeculation;
    711711            } else if (Node::shouldSpeculateArray(left, right)) {
    712                 filter = PredictArray;
    713                 checker = isArrayPrediction;
     712                filter = SpecArray;
     713                checker = isArraySpeculation;
    714714            } else if (left.shouldSpeculateFinalObject() && right.shouldSpeculateFinalObjectOrOther()) {
    715715                node.setCanExit(
    716                     !isFinalObjectPrediction(forNode(node.child1()).m_type)
    717                     || !isFinalObjectOrOtherPrediction(forNode(node.child2()).m_type));
    718                 forNode(node.child1()).filter(PredictFinalObject);
    719                 forNode(node.child2()).filter(PredictFinalObject | PredictOther);
     716                    !isFinalObjectSpeculation(forNode(node.child1()).m_type)
     717                    || !isFinalObjectOrOtherSpeculation(forNode(node.child2()).m_type));
     718                forNode(node.child1()).filter(SpecFinalObject);
     719                forNode(node.child2()).filter(SpecFinalObject | SpecOther);
    720720                break;
    721721            } else if (right.shouldSpeculateFinalObject() && left.shouldSpeculateFinalObjectOrOther()) {
    722722                node.setCanExit(
    723                     !isFinalObjectOrOtherPrediction(forNode(node.child1()).m_type)
    724                     || !isFinalObjectPrediction(forNode(node.child2()).m_type));
    725                 forNode(node.child1()).filter(PredictFinalObject | PredictOther);
    726                 forNode(node.child2()).filter(PredictFinalObject);
     723                    !isFinalObjectOrOtherSpeculation(forNode(node.child1()).m_type)
     724                    || !isFinalObjectSpeculation(forNode(node.child2()).m_type));
     725                forNode(node.child1()).filter(SpecFinalObject | SpecOther);
     726                forNode(node.child2()).filter(SpecFinalObject);
    727727                break;
    728728            } else if (left.shouldSpeculateArray() && right.shouldSpeculateArrayOrOther()) {
    729729                node.setCanExit(
    730                     !isArrayPrediction(forNode(node.child1()).m_type)
    731                     || !isArrayOrOtherPrediction(forNode(node.child2()).m_type));
    732                 forNode(node.child1()).filter(PredictArray);
    733                 forNode(node.child2()).filter(PredictArray | PredictOther);
     730                    !isArraySpeculation(forNode(node.child1()).m_type)
     731                    || !isArrayOrOtherSpeculation(forNode(node.child2()).m_type));
     732                forNode(node.child1()).filter(SpecArray);
     733                forNode(node.child2()).filter(SpecArray | SpecOther);
    734734                break;
    735735            } else if (right.shouldSpeculateArray() && left.shouldSpeculateArrayOrOther()) {
    736736                node.setCanExit(
    737                     !isArrayOrOtherPrediction(forNode(node.child1()).m_type)
    738                     || !isArrayPrediction(forNode(node.child2()).m_type));
    739                 forNode(node.child1()).filter(PredictArray | PredictOther);
    740                 forNode(node.child2()).filter(PredictArray);
     737                    !isArrayOrOtherSpeculation(forNode(node.child1()).m_type)
     738                    || !isArraySpeculation(forNode(node.child2()).m_type));
     739                forNode(node.child1()).filter(SpecArray | SpecOther);
     740                forNode(node.child2()).filter(SpecArray);
    741741                break;
    742742            } else {
    743                 filter = PredictTop;
    744                 checker = isAnyPrediction;
     743                filter = SpecTop;
     744                checker = isAnySpeculation;
    745745                clobberWorld(node.codeOrigin, indexInBlock);
    746746            }
    747747        } else {
    748             filter = PredictTop;
    749             checker = isAnyPrediction;
     748            filter = SpecTop;
     749            checker = isAnySpeculation;
    750750            clobberWorld(node.codeOrigin, indexInBlock);
    751751        }
     
    767767            break;
    768768        }
    769         forNode(nodeIndex).set(PredictBoolean);
     769        forNode(nodeIndex).set(SpecBoolean);
    770770        if (m_graph.isJSConstant(node.child1().index())) {
    771771            JSValue value = m_graph.valueOfJSConstant(node.child1().index());
     
    795795                m_graph[node.child1()], m_graph[node.child2()])) {
    796796            node.setCanExit(
    797                 !isFinalObjectPrediction(forNode(node.child1()).m_type)
    798                 || !isFinalObjectPrediction(forNode(node.child2()).m_type));
    799             forNode(node.child1()).filter(PredictFinalObject);
    800             forNode(node.child2()).filter(PredictFinalObject);
     797                !isFinalObjectSpeculation(forNode(node.child1()).m_type)
     798                || !isFinalObjectSpeculation(forNode(node.child2()).m_type));
     799            forNode(node.child1()).filter(SpecFinalObject);
     800            forNode(node.child2()).filter(SpecFinalObject);
    801801            break;
    802802        }
     
    804804                m_graph[node.child1()], m_graph[node.child2()])) {
    805805            node.setCanExit(
    806                 !isArrayPrediction(forNode(node.child1()).m_type)
    807                 || !isArrayPrediction(forNode(node.child2()).m_type));
    808             forNode(node.child1()).filter(PredictArray);
    809             forNode(node.child2()).filter(PredictArray);
     806                !isArraySpeculation(forNode(node.child1()).m_type)
     807                || !isArraySpeculation(forNode(node.child2()).m_type));
     808            forNode(node.child1()).filter(SpecArray);
     809            forNode(node.child2()).filter(SpecArray);
    810810            break;
    811811        }
     
    816816    case StringCharCodeAt:
    817817        node.setCanExit(true);
    818         forNode(node.child1()).filter(PredictString);
    819         forNode(node.child2()).filter(PredictInt32);
    820         forNode(nodeIndex).set(PredictInt32);
     818        forNode(node.child1()).filter(SpecString);
     819        forNode(node.child2()).filter(SpecInt32);
     820        forNode(nodeIndex).set(SpecInt32);
    821821        break;
    822822       
    823823    case StringCharAt:
    824824        node.setCanExit(true);
    825         forNode(node.child1()).filter(PredictString);
    826         forNode(node.child2()).filter(PredictInt32);
    827         forNode(nodeIndex).set(PredictString);
     825        forNode(node.child1()).filter(SpecString);
     826        forNode(node.child2()).filter(SpecInt32);
     827        forNode(nodeIndex).set(SpecString);
    828828        break;
    829829           
     
    834834            break;
    835835        }
    836         if (!isActionableArrayPrediction(m_graph[node.child1()].prediction()) || !m_graph[node.child2()].shouldSpeculateInteger()) {
     836        if (!isActionableArraySpeculation(m_graph[node.child1()].prediction()) || !m_graph[node.child2()].shouldSpeculateInteger()) {
    837837            clobberWorld(node.codeOrigin, indexInBlock);
    838838            forNode(nodeIndex).makeTop();
     
    840840        }
    841841        if (m_graph[node.child1()].shouldSpeculateArguments()) {
    842             forNode(node.child1()).filter(PredictArguments);
    843             forNode(node.child2()).filter(PredictInt32);
     842            forNode(node.child1()).filter(SpecArguments);
     843            forNode(node.child2()).filter(SpecInt32);
    844844            forNode(nodeIndex).makeTop();
    845845            break;
    846846        }
    847         if (m_graph[node.child1()].prediction() == PredictString) {
    848             forNode(node.child1()).filter(PredictString);
    849             forNode(node.child2()).filter(PredictInt32);
    850             forNode(nodeIndex).set(PredictString);
     847        if (m_graph[node.child1()].prediction() == SpecString) {
     848            forNode(node.child1()).filter(SpecString);
     849            forNode(node.child2()).filter(SpecInt32);
     850            forNode(nodeIndex).set(SpecString);
    851851            break;
    852852        }
    853853       
    854854        if (m_graph[node.child1()].shouldSpeculateInt8Array()) {
    855             forNode(node.child1()).filter(PredictInt8Array);
    856             forNode(node.child2()).filter(PredictInt32);
    857             forNode(nodeIndex).set(PredictInt32);
     855            forNode(node.child1()).filter(SpecInt8Array);
     856            forNode(node.child2()).filter(SpecInt32);
     857            forNode(nodeIndex).set(SpecInt32);
    858858            break;
    859859        }
    860860        if (m_graph[node.child1()].shouldSpeculateInt16Array()) {
    861             forNode(node.child1()).filter(PredictInt16Array);
    862             forNode(node.child2()).filter(PredictInt32);
    863             forNode(nodeIndex).set(PredictInt32);
     861            forNode(node.child1()).filter(SpecInt16Array);
     862            forNode(node.child2()).filter(SpecInt32);
     863            forNode(nodeIndex).set(SpecInt32);
    864864            break;
    865865        }
    866866        if (m_graph[node.child1()].shouldSpeculateInt32Array()) {
    867             forNode(node.child1()).filter(PredictInt32Array);
    868             forNode(node.child2()).filter(PredictInt32);
    869             forNode(nodeIndex).set(PredictInt32);
     867            forNode(node.child1()).filter(SpecInt32Array);
     868            forNode(node.child2()).filter(SpecInt32);
     869            forNode(nodeIndex).set(SpecInt32);
    870870            break;
    871871        }
    872872        if (m_graph[node.child1()].shouldSpeculateUint8Array()) {
    873             forNode(node.child1()).filter(PredictUint8Array);
    874             forNode(node.child2()).filter(PredictInt32);
    875             forNode(nodeIndex).set(PredictInt32);
     873            forNode(node.child1()).filter(SpecUint8Array);
     874            forNode(node.child2()).filter(SpecInt32);
     875            forNode(nodeIndex).set(SpecInt32);
    876876            break;
    877877        }
    878878        if (m_graph[node.child1()].shouldSpeculateUint8ClampedArray()) {
    879             forNode(node.child1()).filter(PredictUint8ClampedArray);
    880             forNode(node.child2()).filter(PredictInt32);
    881             forNode(nodeIndex).set(PredictInt32);
     879            forNode(node.child1()).filter(SpecUint8ClampedArray);
     880            forNode(node.child2()).filter(SpecInt32);
     881            forNode(nodeIndex).set(SpecInt32);
    882882            break;
    883883        }
    884884        if (m_graph[node.child1()].shouldSpeculateUint16Array()) {
    885             forNode(node.child1()).filter(PredictUint16Array);
    886             forNode(node.child2()).filter(PredictInt32);
    887             forNode(nodeIndex).set(PredictInt32);
     885            forNode(node.child1()).filter(SpecUint16Array);
     886            forNode(node.child2()).filter(SpecInt32);
     887            forNode(nodeIndex).set(SpecInt32);
    888888            break;
    889889        }
    890890        if (m_graph[node.child1()].shouldSpeculateUint32Array()) {
    891             forNode(node.child1()).filter(PredictUint32Array);
    892             forNode(node.child2()).filter(PredictInt32);
     891            forNode(node.child1()).filter(SpecUint32Array);
     892            forNode(node.child2()).filter(SpecInt32);
    893893            if (node.shouldSpeculateInteger())
    894                 forNode(nodeIndex).set(PredictInt32);
     894                forNode(nodeIndex).set(SpecInt32);
    895895            else
    896                 forNode(nodeIndex).set(PredictDouble);
     896                forNode(nodeIndex).set(SpecDouble);
    897897            break;
    898898        }
    899899        if (m_graph[node.child1()].shouldSpeculateFloat32Array()) {
    900             forNode(node.child1()).filter(PredictFloat32Array);
    901             forNode(node.child2()).filter(PredictInt32);
    902             forNode(nodeIndex).set(PredictDouble);
     900            forNode(node.child1()).filter(SpecFloat32Array);
     901            forNode(node.child2()).filter(SpecInt32);
     902            forNode(nodeIndex).set(SpecDouble);
    903903            break;
    904904        }
    905905        if (m_graph[node.child1()].shouldSpeculateFloat64Array()) {
    906             forNode(node.child1()).filter(PredictFloat64Array);
    907             forNode(node.child2()).filter(PredictInt32);
    908             forNode(nodeIndex).set(PredictDouble);
     906            forNode(node.child1()).filter(SpecFloat64Array);
     907            forNode(node.child2()).filter(SpecInt32);
     908            forNode(nodeIndex).set(SpecDouble);
    909909            break;
    910910        }
    911911        ASSERT(m_graph[node.child1()].shouldSpeculateArray());
    912         forNode(node.child1()).filter(PredictArray);
    913         forNode(node.child2()).filter(PredictInt32);
     912        forNode(node.child1()).filter(SpecArray);
     913        forNode(node.child2()).filter(SpecInt32);
    914914        forNode(nodeIndex).makeTop();
    915915        break;
     
    923923            break;
    924924        }
    925         if (!m_graph[node.child2()].shouldSpeculateInteger() || !isActionableMutableArrayPrediction(m_graph[node.child1()].prediction())
     925        if (!m_graph[node.child2()].shouldSpeculateInteger() || !isActionableMutableArraySpeculation(m_graph[node.child1()].prediction())
    926926#if USE(JSVALUE32_64)
    927927            || m_graph[node.child1()].shouldSpeculateArguments()
     
    935935       
    936936        if (m_graph[node.child1()].shouldSpeculateArguments()) {
    937             forNode(node.child1()).filter(PredictArguments);
    938             forNode(node.child2()).filter(PredictInt32);
     937            forNode(node.child1()).filter(SpecArguments);
     938            forNode(node.child2()).filter(SpecInt32);
    939939            break;
    940940        }
    941941        if (m_graph[node.child1()].shouldSpeculateInt8Array()) {
    942             forNode(node.child1()).filter(PredictInt8Array);
    943             forNode(node.child2()).filter(PredictInt32);
     942            forNode(node.child1()).filter(SpecInt8Array);
     943            forNode(node.child2()).filter(SpecInt32);
    944944            if (m_graph[node.child3()].shouldSpeculateInteger())
    945                 forNode(node.child3()).filter(PredictInt32);
     945                forNode(node.child3()).filter(SpecInt32);
    946946            else
    947                 forNode(node.child3()).filter(PredictNumber);
     947                forNode(node.child3()).filter(SpecNumber);
    948948            break;
    949949        }
    950950        if (m_graph[node.child1()].shouldSpeculateInt16Array()) {
    951             forNode(node.child1()).filter(PredictInt16Array);
    952             forNode(node.child2()).filter(PredictInt32);
     951            forNode(node.child1()).filter(SpecInt16Array);
     952            forNode(node.child2()).filter(SpecInt32);
    953953            if (m_graph[node.child3()].shouldSpeculateInteger())
    954                 forNode(node.child3()).filter(PredictInt32);
     954                forNode(node.child3()).filter(SpecInt32);
    955955            else
    956                 forNode(node.child3()).filter(PredictNumber);
     956                forNode(node.child3()).filter(SpecNumber);
    957957            break;
    958958        }
    959959        if (m_graph[node.child1()].shouldSpeculateInt32Array()) {
    960             forNode(node.child1()).filter(PredictInt32Array);
    961             forNode(node.child2()).filter(PredictInt32);
     960            forNode(node.child1()).filter(SpecInt32Array);
     961            forNode(node.child2()).filter(SpecInt32);
    962962            if (m_graph[node.child3()].shouldSpeculateInteger())
    963                 forNode(node.child3()).filter(PredictInt32);
     963                forNode(node.child3()).filter(SpecInt32);
    964964            else
    965                 forNode(node.child3()).filter(PredictNumber);
     965                forNode(node.child3()).filter(SpecNumber);
    966966            break;
    967967        }
    968968        if (m_graph[node.child1()].shouldSpeculateUint8Array()) {
    969             forNode(node.child1()).filter(PredictUint8Array);
    970             forNode(node.child2()).filter(PredictInt32);
     969            forNode(node.child1()).filter(SpecUint8Array);
     970            forNode(node.child2()).filter(SpecInt32);
    971971            if (m_graph[node.child3()].shouldSpeculateInteger())
    972                 forNode(node.child3()).filter(PredictInt32);
     972                forNode(node.child3()).filter(SpecInt32);
    973973            else
    974                 forNode(node.child3()).filter(PredictNumber);
     974                forNode(node.child3()).filter(SpecNumber);
    975975            break;
    976976        }
    977977        if (m_graph[node.child1()].shouldSpeculateUint8ClampedArray()) {
    978             forNode(node.child1()).filter(PredictUint8ClampedArray);
    979             forNode(node.child2()).filter(PredictInt32);
     978            forNode(node.child1()).filter(SpecUint8ClampedArray);
     979            forNode(node.child2()).filter(SpecInt32);
    980980            if (m_graph[node.child3()].shouldSpeculateInteger())
    981                 forNode(node.child3()).filter(PredictInt32);
     981                forNode(node.child3()).filter(SpecInt32);
    982982            else
    983                 forNode(node.child3()).filter(PredictNumber);
     983                forNode(node.child3()).filter(SpecNumber);
    984984            break;
    985985        }
    986986        if (m_graph[node.child1()].shouldSpeculateUint16Array()) {
    987             forNode(node.child1()).filter(PredictUint16Array);
    988             forNode(node.child2()).filter(PredictInt32);
     987            forNode(node.child1()).filter(SpecUint16Array);
     988            forNode(node.child2()).filter(SpecInt32);
    989989            if (m_graph[node.child3()].shouldSpeculateInteger())
    990                 forNode(node.child3()).filter(PredictInt32);
     990                forNode(node.child3()).filter(SpecInt32);
    991991            else
    992                 forNode(node.child3()).filter(PredictNumber);
     992                forNode(node.child3()).filter(SpecNumber);
    993993            break;
    994994        }
    995995        if (m_graph[node.child1()].shouldSpeculateUint32Array()) {
    996             forNode(node.child1()).filter(PredictUint32Array);
    997             forNode(node.child2()).filter(PredictInt32);
     996            forNode(node.child1()).filter(SpecUint32Array);
     997            forNode(node.child2()).filter(SpecInt32);
    998998            if (m_graph[node.child3()].shouldSpeculateInteger())
    999                 forNode(node.child3()).filter(PredictInt32);
     999                forNode(node.child3()).filter(SpecInt32);
    10001000            else
    1001                 forNode(node.child3()).filter(PredictNumber);
     1001                forNode(node.child3()).filter(SpecNumber);
    10021002            break;
    10031003        }
    10041004        if (m_graph[node.child1()].shouldSpeculateFloat32Array()) {
    1005             forNode(node.child1()).filter(PredictFloat32Array);
    1006             forNode(node.child2()).filter(PredictInt32);
    1007             forNode(node.child3()).filter(PredictNumber);
     1005            forNode(node.child1()).filter(SpecFloat32Array);
     1006            forNode(node.child2()).filter(SpecInt32);
     1007            forNode(node.child3()).filter(SpecNumber);
    10081008            break;
    10091009        }
    10101010        if (m_graph[node.child1()].shouldSpeculateFloat64Array()) {
    1011             forNode(node.child1()).filter(PredictFloat64Array);
    1012             forNode(node.child2()).filter(PredictInt32);
    1013             forNode(node.child3()).filter(PredictNumber);
     1011            forNode(node.child1()).filter(SpecFloat64Array);
     1012            forNode(node.child2()).filter(SpecInt32);
     1013            forNode(node.child3()).filter(SpecNumber);
    10141014            break;
    10151015        }
    10161016        ASSERT(m_graph[node.child1()].shouldSpeculateArray());
    1017         forNode(node.child1()).filter(PredictArray);
    1018         forNode(node.child2()).filter(PredictInt32);
     1017        forNode(node.child1()).filter(SpecArray);
     1018        forNode(node.child2()).filter(SpecInt32);
    10191019        if (node.op() == PutByVal)
    10201020            clobberWorld(node.codeOrigin, indexInBlock);
     
    10241024    case ArrayPush:
    10251025        node.setCanExit(true);
    1026         forNode(node.child1()).filter(PredictArray);
    1027         forNode(nodeIndex).set(PredictNumber);
     1026        forNode(node.child1()).filter(SpecArray);
     1027        forNode(nodeIndex).set(SpecNumber);
    10281028        break;
    10291029           
    10301030    case ArrayPop:
    10311031        node.setCanExit(true);
    1032         forNode(node.child1()).filter(PredictArray);
     1032        forNode(node.child1()).filter(SpecArray);
    10331033        forNode(nodeIndex).makeTop();
    10341034        break;
     
    10371037    case RegExpTest:
    10381038        node.setCanExit(
    1039             !isCellPrediction(forNode(node.child1()).m_type)
    1040             || !isCellPrediction(forNode(node.child2()).m_type));
    1041         forNode(node.child1()).filter(PredictCell);
    1042         forNode(node.child2()).filter(PredictCell);
     1039            !isCellSpeculation(forNode(node.child1()).m_type)
     1040            || !isCellSpeculation(forNode(node.child2()).m_type));
     1041        forNode(node.child1()).filter(SpecCell);
     1042        forNode(node.child2()).filter(SpecCell);
    10431043        forNode(nodeIndex).makeTop();
    10441044        break;
     
    10711071        else if (child.shouldSpeculateFinalObjectOrOther()) {
    10721072            node.setCanExit(
    1073                 !isFinalObjectOrOtherPrediction(forNode(node.child1()).m_type));
    1074             forNode(node.child1()).filter(PredictFinalObject | PredictOther);
     1073                !isFinalObjectOrOtherSpeculation(forNode(node.child1()).m_type));
     1074            forNode(node.child1()).filter(SpecFinalObject | SpecOther);
    10751075        } else if (child.shouldSpeculateArrayOrOther()) {
    10761076            node.setCanExit(
    1077                 !isArrayOrOtherPrediction(forNode(node.child1()).m_type));
    1078             forNode(node.child1()).filter(PredictArray | PredictOther);
     1077                !isArrayOrOtherSpeculation(forNode(node.child1()).m_type));
     1078            forNode(node.child1()).filter(SpecArray | SpecOther);
    10791079        } else if (child.shouldSpeculateInteger())
    10801080            speculateInt32Unary(node);
     
    11101110        if (child.shouldSpeculateInteger()) {
    11111111            speculateInt32Unary(node);
    1112             forNode(nodeIndex).set(PredictInt32);
     1112            forNode(nodeIndex).set(SpecInt32);
    11131113            break;
    11141114        }
     
    11171117        AbstractValue& destination = forNode(nodeIndex);
    11181118           
    1119         PredictedType type = source.m_type;
    1120         if (type & ~(PredictNumber | PredictString | PredictBoolean)) {
    1121             type &= (PredictNumber | PredictString | PredictBoolean);
    1122             type |= PredictString;
     1119        SpeculatedType type = source.m_type;
     1120        if (type & ~(SpecNumber | SpecString | SpecBoolean)) {
     1121            type &= (SpecNumber | SpecString | SpecBoolean);
     1122            type |= SpecString;
    11231123        }
    11241124        destination.set(type);
     
    11291129    case StrCat:
    11301130        node.setCanExit(false);
    1131         forNode(nodeIndex).set(PredictString);
     1131        forNode(nodeIndex).set(SpecString);
    11321132        break;
    11331133           
     
    11501150        AbstractValue& destination = forNode(nodeIndex);
    11511151           
    1152         if (isObjectPrediction(source.m_type)) {
     1152        if (isObjectSpeculation(source.m_type)) {
    11531153            // This is the simple case. We already know that the source is an
    11541154            // object, so there's nothing to do. I don't think this case will
     
    11611161        node.setCanExit(true);
    11621162       
    1163         if (isOtherPrediction(child.prediction())) {
    1164             source.filter(PredictOther);
    1165             destination.set(PredictObjectOther);
    1166             break;
    1167         }
    1168        
    1169         if (isObjectPrediction(child.prediction())) {
    1170             source.filter(PredictObjectMask);
     1163        if (isOtherSpeculation(child.prediction())) {
     1164            source.filter(SpecOther);
     1165            destination.set(SpecObjectOther);
     1166            break;
     1167        }
     1168       
     1169        if (isObjectSpeculation(child.prediction())) {
     1170            source.filter(SpecObjectMask);
    11711171            destination = source;
    11721172            break;
     
    11741174           
    11751175        destination = source;
    1176         destination.merge(PredictObjectOther);
     1176        destination.merge(SpecObjectOther);
    11771177        break;
    11781178    }
     
    11821182        AbstractValue& destination = forNode(nodeIndex);
    11831183       
    1184         node.setCanExit(!isCellPrediction(source.m_type));
    1185            
    1186         source.filter(PredictFunction);
    1187         destination.set(PredictFinalObject);
     1184        node.setCanExit(!isCellSpeculation(source.m_type));
     1185           
     1186        source.filter(SpecFunction);
     1187        destination.set(SpecFinalObject);
    11881188        break;
    11891189    }
     
    12141214
    12151215    case CheckArgumentsNotCreated:
    1216         if (isEmptyPrediction(
     1216        if (isEmptySpeculation(
    12171217                m_variables.operand(
    12181218                    m_graph.argumentsRegisterFor(node.codeOrigin)).m_type)) {
     
    12311231            forNode(nodeIndex).set(jsNumber(node.codeOrigin.inlineCallFrame->arguments.size() - 1));
    12321232        else
    1233             forNode(nodeIndex).set(PredictInt32);
     1233            forNode(nodeIndex).set(SpecInt32);
    12341234        node.setCanExit(
    1235             !isEmptyPrediction(
     1235            !isEmptySpeculation(
    12361236                m_variables.operand(
    12371237                    m_graph.argumentsRegisterFor(node.codeOrigin)).m_type));
     
    12531253        // the arguments a bit. Note that this ends up being further optimized by the
    12541254        // ArgumentsSimplificationPhase.
    1255         forNode(node.child1()).filter(PredictInt32);
     1255        forNode(node.child1()).filter(SpecInt32);
    12561256        forNode(nodeIndex).makeTop();
    12571257        break;
     
    12631263        clobberWorld(node.codeOrigin, indexInBlock);
    12641264        // But we do speculate that the index is an integer.
    1265         forNode(node.child1()).filter(PredictInt32);
     1265        forNode(node.child1()).filter(SpecInt32);
    12661266        // And the result is unknown.
    12671267        forNode(nodeIndex).makeTop();
     
    12771277    case GetCallee:
    12781278        node.setCanExit(false);
    1279         forNode(nodeIndex).set(PredictFunction);
     1279        forNode(nodeIndex).set(SpecFunction);
    12801280        break;
    12811281           
    12821282    case GetScopeChain:
    12831283        node.setCanExit(false);
    1284         forNode(nodeIndex).set(PredictCellOther);
     1284        forNode(nodeIndex).set(SpecCellOther);
    12851285        break;
    12861286           
     
    13021302            break;
    13031303        }
    1304         if (isCellPrediction(m_graph[node.child1()].prediction()))
    1305             forNode(node.child1()).filter(PredictCell);
     1304        if (isCellSpeculation(m_graph[node.child1()].prediction()))
     1305            forNode(node.child1()).filter(SpecCell);
    13061306        clobberWorld(node.codeOrigin, indexInBlock);
    13071307        forNode(nodeIndex).makeTop();
     
    13101310    case GetArrayLength:
    13111311        node.setCanExit(true);
    1312         forNode(node.child1()).filter(PredictArray);
    1313         forNode(nodeIndex).set(PredictInt32);
     1312        forNode(node.child1()).filter(SpecArray);
     1313        forNode(nodeIndex).set(SpecInt32);
    13141314        break;
    13151315
    13161316    case GetArgumentsLength:
    13171317        node.setCanExit(true);
    1318         forNode(node.child1()).filter(PredictArguments);
    1319         forNode(nodeIndex).set(PredictInt32);
     1318        forNode(node.child1()).filter(SpecArguments);
     1319        forNode(nodeIndex).set(SpecInt32);
    13201320        break;
    13211321
    13221322    case GetStringLength:
    1323         node.setCanExit(!isStringPrediction(forNode(node.child1()).m_type));
    1324         forNode(node.child1()).filter(PredictString);
    1325         forNode(nodeIndex).set(PredictInt32);
     1323        node.setCanExit(!isStringSpeculation(forNode(node.child1()).m_type));
     1324        forNode(node.child1()).filter(SpecString);
     1325        forNode(nodeIndex).set(SpecInt32);
    13261326        break;
    13271327       
    13281328    case GetInt8ArrayLength:
    1329         node.setCanExit(!isInt8ArrayPrediction(forNode(node.child1()).m_type));
    1330         forNode(node.child1()).filter(PredictInt8Array);
    1331         forNode(nodeIndex).set(PredictInt32);
     1329        node.setCanExit(!isInt8ArraySpeculation(forNode(node.child1()).m_type));
     1330        forNode(node.child1()).filter(SpecInt8Array);
     1331        forNode(nodeIndex).set(SpecInt32);
    13321332        break;
    13331333    case GetInt16ArrayLength:
    1334         node.setCanExit(!isInt16ArrayPrediction(forNode(node.child1()).m_type));
    1335         forNode(node.child1()).filter(PredictInt16Array);
    1336         forNode(nodeIndex).set(PredictInt32);
     1334        node.setCanExit(!isInt16ArraySpeculation(forNode(node.child1()).m_type));
     1335        forNode(node.child1()).filter(SpecInt16Array);
     1336        forNode(nodeIndex).set(SpecInt32);
    13371337        break;
    13381338    case GetInt32ArrayLength:
    1339         node.setCanExit(!isInt32ArrayPrediction(forNode(node.child1()).m_type));
    1340         forNode(node.child1()).filter(PredictInt32Array);
    1341         forNode(nodeIndex).set(PredictInt32);
     1339        node.setCanExit(!isInt32ArraySpeculation(forNode(node.child1()).m_type));
     1340        forNode(node.child1()).filter(SpecInt32Array);
     1341        forNode(nodeIndex).set(SpecInt32);
    13421342        break;
    13431343    case GetUint8ArrayLength:
    1344         node.setCanExit(!isUint8ArrayPrediction(forNode(node.child1()).m_type));
    1345         forNode(node.child1()).filter(PredictUint8Array);
    1346         forNode(nodeIndex).set(PredictInt32);
     1344        node.setCanExit(!isUint8ArraySpeculation(forNode(node.child1()).m_type));
     1345        forNode(node.child1()).filter(SpecUint8Array);
     1346        forNode(nodeIndex).set(SpecInt32);
    13471347        break;
    13481348    case GetUint8ClampedArrayLength:
    1349         node.setCanExit(!isUint8ClampedArrayPrediction(forNode(node.child1()).m_type));
    1350         forNode(node.child1()).filter(PredictUint8ClampedArray);
    1351         forNode(nodeIndex).set(PredictInt32);
     1349        node.setCanExit(!isUint8ClampedArraySpeculation(forNode(node.child1()).m_type));
     1350        forNode(node.child1()).filter(SpecUint8ClampedArray);
     1351        forNode(nodeIndex).set(SpecInt32);
    13521352        break;
    13531353    case GetUint16ArrayLength:
    1354         node.setCanExit(!isUint16ArrayPrediction(forNode(node.child1()).m_type));
    1355         forNode(node.child1()).filter(PredictUint16Array);
    1356         forNode(nodeIndex).set(PredictInt32);
     1354        node.setCanExit(!isUint16ArraySpeculation(forNode(node.child1()).m_type));
     1355        forNode(node.child1()).filter(SpecUint16Array);
     1356        forNode(nodeIndex).set(SpecInt32);
    13571357        break;
    13581358    case GetUint32ArrayLength:
    1359         node.setCanExit(!isUint32ArrayPrediction(forNode(node.child1()).m_type));
    1360         forNode(node.child1()).filter(PredictUint32Array);
    1361         forNode(nodeIndex).set(PredictInt32);
     1359        node.setCanExit(!isUint32ArraySpeculation(forNode(node.child1()).m_type));
     1360        forNode(node.child1()).filter(SpecUint32Array);
     1361        forNode(nodeIndex).set(SpecInt32);
    13621362        break;
    13631363    case GetFloat32ArrayLength:
    1364         node.setCanExit(!isFloat32ArrayPrediction(forNode(node.child1()).m_type));
    1365         forNode(node.child1()).filter(PredictFloat32Array);
    1366         forNode(nodeIndex).set(PredictInt32);
     1364        node.setCanExit(!isFloat32ArraySpeculation(forNode(node.child1()).m_type));
     1365        forNode(node.child1()).filter(SpecFloat32Array);
     1366        forNode(nodeIndex).set(SpecInt32);
    13671367        break;
    13681368    case GetFloat64ArrayLength:
    1369         node.setCanExit(!isFloat64ArrayPrediction(forNode(node.child1()).m_type));
    1370         forNode(node.child1()).filter(PredictFloat64Array);
    1371         forNode(nodeIndex).set(PredictInt32);
     1369        node.setCanExit(!isFloat64ArraySpeculation(forNode(node.child1()).m_type));
     1370        forNode(node.child1()).filter(SpecFloat64Array);
     1371        forNode(nodeIndex).set(SpecInt32);
    13721372        break;
    13731373           
     
    13771377        node.setCanExit(
    13781378            !value.m_structure.isSubsetOf(node.structureSet())
    1379             || !isCellPrediction(value.m_type));
     1379            || !isCellSpeculation(value.m_type));
    13801380        value.filter(node.structureSet());
    13811381        m_haveStructures = true;
     
    13921392    case GetPropertyStorage:
    13931393        node.setCanExit(false);
    1394         forNode(node.child1()).filter(PredictCell);
     1394        forNode(node.child1()).filter(SpecCell);
    13951395        forNode(nodeIndex).clear(); // The result is not a JS value.
    13961396        break;
    13971397    case GetIndexedPropertyStorage: {
    13981398        node.setCanExit(true); // Lies, but this is (almost) always followed by GetByVal, which does exit. So no point in trying to be more precise.
    1399         PredictedType basePrediction = m_graph[node.child2()].prediction();
    1400         if (!(basePrediction & PredictInt32) && basePrediction) {
     1399        SpeculatedType basePrediction = m_graph[node.child2()].prediction();
     1400        if (!(basePrediction & SpecInt32) && basePrediction) {
    14011401            forNode(nodeIndex).clear();
    14021402            break;
     
    14061406            break;
    14071407        }
    1408         if (m_graph[node.child1()].prediction() == PredictString) {
    1409             forNode(node.child1()).filter(PredictString);
     1408        if (m_graph[node.child1()].prediction() == SpecString) {
     1409            forNode(node.child1()).filter(SpecString);
    14101410            forNode(nodeIndex).clear();
    14111411            break;
     
    14131413       
    14141414        if (m_graph[node.child1()].shouldSpeculateInt8Array()) {
    1415             forNode(node.child1()).filter(PredictInt8Array);
     1415            forNode(node.child1()).filter(SpecInt8Array);
    14161416            forNode(nodeIndex).clear();
    14171417            break;
    14181418        }
    14191419        if (m_graph[node.child1()].shouldSpeculateInt16Array()) {
    1420             forNode(node.child1()).filter(PredictInt16Array);
     1420            forNode(node.child1()).filter(SpecInt16Array);
    14211421            forNode(nodeIndex).clear();
    14221422            break;
    14231423        }
    14241424        if (m_graph[node.child1()].shouldSpeculateInt32Array()) {
    1425             forNode(node.child1()).filter(PredictInt32Array);
     1425            forNode(node.child1()).filter(SpecInt32Array);
    14261426            forNode(nodeIndex).clear();
    14271427            break;
    14281428        }
    14291429        if (m_graph[node.child1()].shouldSpeculateUint8Array()) {
    1430             forNode(node.child1()).filter(PredictUint8Array);
     1430            forNode(node.child1()).filter(SpecUint8Array);
    14311431            forNode(nodeIndex).clear();
    14321432            break;
    14331433        }
    14341434        if (m_graph[node.child1()].shouldSpeculateUint8ClampedArray()) {
    1435             forNode(node.child1()).filter(PredictUint8ClampedArray);
     1435            forNode(node.child1()).filter(SpecUint8ClampedArray);
    14361436            forNode(nodeIndex).clear();
    14371437            break;
    14381438        }
    14391439        if (m_graph[node.child1()].shouldSpeculateUint16Array()) {
    1440             forNode(node.child1()).filter(PredictUint16Array);
    1441             forNode(nodeIndex).set(PredictOther);
     1440            forNode(node.child1()).filter(SpecUint16Array);
     1441            forNode(nodeIndex).set(SpecOther);
    14421442            break;
    14431443        }
    14441444        if (m_graph[node.child1()].shouldSpeculateUint32Array()) {
    1445             forNode(node.child1()).filter(PredictUint32Array);
     1445            forNode(node.child1()).filter(SpecUint32Array);
    14461446            forNode(nodeIndex).clear();
    14471447            break;
    14481448        }
    14491449        if (m_graph[node.child1()].shouldSpeculateFloat32Array()) {
    1450             forNode(node.child1()).filter(PredictFloat32Array);
     1450            forNode(node.child1()).filter(SpecFloat32Array);
    14511451            forNode(nodeIndex).clear();
    14521452            break;
    14531453        }
    14541454        if (m_graph[node.child1()].shouldSpeculateFloat64Array()) {
    1455             forNode(node.child1()).filter(PredictFloat64Array);
     1455            forNode(node.child1()).filter(SpecFloat64Array);
    14561456            forNode(nodeIndex).clear();
    14571457            break;
    14581458        }
    1459         forNode(node.child1()).filter(PredictArray);
     1459        forNode(node.child1()).filter(SpecArray);
    14601460        forNode(nodeIndex).clear();
    14611461        break;
     
    14631463    case GetByOffset:
    14641464        node.setCanExit(false);
    1465         forNode(node.child1()).filter(PredictCell);
     1465        forNode(node.child1()).filter(SpecCell);
    14661466        forNode(nodeIndex).makeTop();
    14671467        break;
     
    14691469    case PutByOffset:
    14701470        node.setCanExit(false);
    1471         forNode(node.child1()).filter(PredictCell);
     1471        forNode(node.child1()).filter(SpecCell);
    14721472        break;
    14731473           
    14741474    case CheckFunction:
    14751475        node.setCanExit(true); // Lies! We can do better.
    1476         forNode(node.child1()).filter(PredictFunction);
     1476        forNode(node.child1()).filter(SpecFunction);
    14771477        // FIXME: Should be able to propagate the fact that we know what the function is.
    14781478        break;
     
    14811481    case PutByIdDirect:
    14821482        node.setCanExit(true);
    1483         forNode(node.child1()).filter(PredictCell);
     1483        forNode(node.child1()).filter(SpecCell);
    14841484        clobberWorld(node.codeOrigin, indexInBlock);
    14851485        break;
     
    14961496    case CheckHasInstance:
    14971497        node.setCanExit(true);
    1498         forNode(node.child1()).filter(PredictCell);
     1498        forNode(node.child1()).filter(SpecCell);
    14991499        // Sadly, we don't propagate the fact that we've done CheckHasInstance
    15001500        break;
     
    15031503        node.setCanExit(true);
    15041504        // Again, sadly, we don't propagate the fact that we've done InstanceOf
    1505         if (!(m_graph[node.child1()].prediction() & ~PredictCell) && !(forNode(node.child1()).m_type & ~PredictCell))
    1506             forNode(node.child1()).filter(PredictCell);
    1507         forNode(node.child3()).filter(PredictCell);
    1508         forNode(nodeIndex).set(PredictBoolean);
     1505        if (!(m_graph[node.child1()].prediction() & ~SpecCell) && !(forNode(node.child1()).m_type & ~SpecCell))
     1506            forNode(node.child1()).filter(SpecCell);
     1507        forNode(node.child3()).filter(SpecCell);
     1508        forNode(nodeIndex).set(SpecBoolean);
    15091509        break;
    15101510           
     
    16321632            if (node.variableAccessData()->shouldUseDoubleFormat()) {
    16331633                // FIXME: This unnecessarily loses precision.
    1634                 source.set(PredictDouble);
     1634                source.set(SpecDouble);
    16351635            } else
    16361636                source = forNode(node.child1());
Note: See TracChangeset for help on using the changeset viewer.