Changeset 119660 in webkit for trunk/Source/JavaScriptCore/dfg/DFGAbstractState.cpp
- Timestamp:
- Jun 6, 2012, 6:35:59 PM (13 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/Source/JavaScriptCore/dfg/DFGAbstractState.cpp
r119342 r119660 100 100 } 101 101 102 PredictedType prediction = node.variableAccessData()->prediction();103 if (isInt32 Prediction(prediction))104 root->valuesAtHead.argument(i).set( PredictInt32);105 else if (isArray Prediction(prediction))106 root->valuesAtHead.argument(i).set( PredictArray);107 else if (isBoolean Prediction(prediction))108 root->valuesAtHead.argument(i).set( PredictBoolean);109 else if (isInt8Array Prediction(prediction))110 root->valuesAtHead.argument(i).set( PredictInt8Array);111 else if (isInt16Array Prediction(prediction))112 root->valuesAtHead.argument(i).set( PredictInt16Array);113 else if (isInt32Array Prediction(prediction))114 root->valuesAtHead.argument(i).set( PredictInt32Array);115 else if (isUint8Array Prediction(prediction))116 root->valuesAtHead.argument(i).set( PredictUint8Array);117 else if (isUint8ClampedArray Prediction(prediction))118 root->valuesAtHead.argument(i).set( PredictUint8ClampedArray);119 else if (isUint16Array Prediction(prediction))120 root->valuesAtHead.argument(i).set( PredictUint16Array);121 else if (isUint32Array Prediction(prediction))122 root->valuesAtHead.argument(i).set( PredictUint32Array);123 else if (isFloat32Array Prediction(prediction))124 root->valuesAtHead.argument(i).set( PredictFloat32Array);125 else if (isFloat64Array Prediction(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); 127 127 else 128 128 root->valuesAtHead.argument(i).makeTop(); … … 239 239 VariableAccessData* variableAccessData = node.variableAccessData(); 240 240 bool canExit = false; 241 canExit |= variableAccessData->prediction() == PredictNone;241 canExit |= variableAccessData->prediction() == SpecNone; 242 242 AbstractValue value = m_variables.operand(variableAccessData->local()); 243 243 if (!variableAccessData->isCaptured()) { … … 270 270 if (node.variableAccessData()->shouldUseDoubleFormat()) { 271 271 speculateNumberUnary(node); 272 m_variables.operand(node.local()).set( PredictDouble);273 break; 274 } 275 276 PredictedType predictedType = node.variableAccessData()->argumentAwarePrediction();277 if (isInt32 Prediction(predictedType))272 m_variables.operand(node.local()).set(SpecDouble); 273 break; 274 } 275 276 SpeculatedType predictedType = node.variableAccessData()->argumentAwarePrediction(); 277 if (isInt32Speculation(predictedType)) 278 278 speculateInt32Unary(node); 279 else if (isArray Prediction(predictedType)) {280 node.setCanExit(!isArray Prediction(forNode(node.child1()).m_type));281 forNode(node.child1()).filter( PredictArray);282 } else if (isBoolean Prediction(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)) 283 283 speculateBooleanUnary(node); 284 284 else … … 333 333 } 334 334 speculateInt32Binary(node); 335 forNode(nodeIndex).set( PredictInt32);335 forNode(nodeIndex).set(SpecInt32); 336 336 break; 337 337 } … … 347 347 } 348 348 if (!node.canSpeculateInteger()) { 349 forNode(nodeIndex).set( PredictDouble);349 forNode(nodeIndex).set(SpecDouble); 350 350 node.setCanExit(false); 351 351 } else { 352 forNode(nodeIndex).set( PredictInt32);352 forNode(nodeIndex).set(SpecInt32); 353 353 node.setCanExit(true); 354 354 } … … 369 369 } 370 370 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); 373 373 break; 374 374 } … … 394 394 node.setCanExit(false); 395 395 396 forNode(nodeIndex).set( PredictInt32);396 forNode(nodeIndex).set(SpecInt32); 397 397 break; 398 398 } … … 407 407 } 408 408 speculateNumberUnary(node); 409 forNode(nodeIndex).set( PredictDouble);409 forNode(nodeIndex).set(SpecDouble); 410 410 break; 411 411 } 412 412 413 413 case CheckNumber: 414 forNode(node.child1()).filter( PredictNumber);414 forNode(node.child1()).filter(SpecNumber); 415 415 break; 416 416 … … 428 428 speculateInt32Binary( 429 429 node, !nodeCanTruncateInteger(node.arithNodeFlags())); 430 forNode(nodeIndex).set( PredictInt32);430 forNode(nodeIndex).set(SpecInt32); 431 431 break; 432 432 } 433 433 if (Node::shouldSpeculateNumber(m_graph[node.child1()], m_graph[node.child2()])) { 434 434 speculateNumberBinary(node); 435 forNode(nodeIndex).set( PredictDouble);435 forNode(nodeIndex).set(SpecDouble); 436 436 break; 437 437 } 438 438 if (node.op() == ValueAdd) { 439 439 clobberWorld(node.codeOrigin, indexInBlock); 440 forNode(nodeIndex).set( PredictString | PredictInt32 | PredictNumber);440 forNode(nodeIndex).set(SpecString | SpecInt32 | SpecNumber); 441 441 node.setCanExit(false); 442 442 break; … … 460 460 speculateInt32Binary( 461 461 node, !nodeCanTruncateInteger(node.arithNodeFlags())); 462 forNode(nodeIndex).set( PredictInt32);462 forNode(nodeIndex).set(SpecInt32); 463 463 break; 464 464 } 465 465 speculateNumberBinary(node); 466 forNode(nodeIndex).set( PredictDouble);466 forNode(nodeIndex).set(SpecDouble); 467 467 break; 468 468 } … … 479 479 speculateInt32Unary( 480 480 node, !nodeCanTruncateInteger(node.arithNodeFlags())); 481 forNode(nodeIndex).set( PredictInt32);481 forNode(nodeIndex).set(SpecInt32); 482 482 break; 483 483 } 484 484 speculateNumberUnary(node); 485 forNode(nodeIndex).set( PredictDouble);485 forNode(nodeIndex).set(SpecDouble); 486 486 break; 487 487 } … … 501 501 !nodeCanTruncateInteger(node.arithNodeFlags()) 502 502 || !nodeCanIgnoreNegativeZero(node.arithNodeFlags())); 503 forNode(nodeIndex).set( PredictInt32);503 forNode(nodeIndex).set(SpecInt32); 504 504 break; 505 505 } 506 506 speculateNumberBinary(node); 507 forNode(nodeIndex).set( PredictDouble);507 forNode(nodeIndex).set(SpecDouble); 508 508 break; 509 509 } … … 543 543 && node.canSpeculateInteger()) { 544 544 speculateInt32Binary(node, true); // forcing can-exit, which is a bit on the conservative side. 545 forNode(nodeIndex).set( PredictInt32);545 forNode(nodeIndex).set(SpecInt32); 546 546 break; 547 547 } 548 548 speculateNumberBinary(node); 549 forNode(nodeIndex).set( PredictDouble);549 forNode(nodeIndex).set(SpecDouble); 550 550 break; 551 551 } … … 562 562 && node.canSpeculateInteger()) { 563 563 speculateInt32Unary(node, true); 564 forNode(nodeIndex).set( PredictInt32);564 forNode(nodeIndex).set(SpecInt32); 565 565 break; 566 566 } 567 567 speculateNumberUnary(node); 568 forNode(nodeIndex).set( PredictDouble);568 forNode(nodeIndex).set(SpecDouble); 569 569 break; 570 570 } … … 579 579 } 580 580 speculateNumberUnary(node); 581 forNode(nodeIndex).set( PredictDouble);581 forNode(nodeIndex).set(SpecDouble); 582 582 break; 583 583 } … … 591 591 } 592 592 Node& child = m_graph[node.child1()]; 593 if (isBoolean Prediction(child.prediction()))593 if (isBooleanSpeculation(child.prediction())) 594 594 speculateBooleanUnary(node); 595 595 else if (child.shouldSpeculateFinalObjectOrOther()) { 596 596 node.setCanExit( 597 !isFinalObjectOrOther Prediction(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); 599 599 } else if (child.shouldSpeculateArrayOrOther()) { 600 600 node.setCanExit( 601 !isArrayOrOther Prediction(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); 603 603 } else if (child.shouldSpeculateInteger()) 604 604 speculateInt32Unary(node); … … 607 607 else 608 608 node.setCanExit(false); 609 forNode(nodeIndex).set( PredictBoolean);609 forNode(nodeIndex).set(SpecBoolean); 610 610 break; 611 611 } … … 645 645 } 646 646 } 647 forNode(nodeIndex).set( PredictBoolean);647 forNode(nodeIndex).set(SpecBoolean); 648 648 break; 649 649 } … … 684 684 } 685 685 686 forNode(nodeIndex).set( PredictBoolean);686 forNode(nodeIndex).set(SpecBoolean); 687 687 688 688 Node& left = m_graph[node.child1()]; 689 689 Node& right = m_graph[node.child2()]; 690 PredictedType filter;691 PredictionChecker checker;690 SpeculatedType filter; 691 SpeculatedTypeChecker checker; 692 692 if (Node::shouldSpeculateInteger(left, right)) { 693 filter = PredictInt32;694 checker = isInt32 Prediction;693 filter = SpecInt32; 694 checker = isInt32Speculation; 695 695 } else if (Node::shouldSpeculateNumber(left, right)) { 696 filter = PredictNumber;697 checker = isNumber Prediction;696 filter = SpecNumber; 697 checker = isNumberSpeculation; 698 698 } else if (node.op() == CompareEq) { 699 699 if ((m_graph.isConstant(node.child1().index()) … … 707 707 708 708 if (Node::shouldSpeculateFinalObject(left, right)) { 709 filter = PredictFinalObject;710 checker = isFinalObject Prediction;709 filter = SpecFinalObject; 710 checker = isFinalObjectSpeculation; 711 711 } else if (Node::shouldSpeculateArray(left, right)) { 712 filter = PredictArray;713 checker = isArray Prediction;712 filter = SpecArray; 713 checker = isArraySpeculation; 714 714 } else if (left.shouldSpeculateFinalObject() && right.shouldSpeculateFinalObjectOrOther()) { 715 715 node.setCanExit( 716 !isFinalObject Prediction(forNode(node.child1()).m_type)717 || !isFinalObjectOrOther Prediction(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); 720 720 break; 721 721 } else if (right.shouldSpeculateFinalObject() && left.shouldSpeculateFinalObjectOrOther()) { 722 722 node.setCanExit( 723 !isFinalObjectOrOther Prediction(forNode(node.child1()).m_type)724 || !isFinalObject Prediction(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); 727 727 break; 728 728 } else if (left.shouldSpeculateArray() && right.shouldSpeculateArrayOrOther()) { 729 729 node.setCanExit( 730 !isArray Prediction(forNode(node.child1()).m_type)731 || !isArrayOrOther Prediction(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); 734 734 break; 735 735 } else if (right.shouldSpeculateArray() && left.shouldSpeculateArrayOrOther()) { 736 736 node.setCanExit( 737 !isArrayOrOther Prediction(forNode(node.child1()).m_type)738 || !isArray Prediction(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); 741 741 break; 742 742 } else { 743 filter = PredictTop;744 checker = isAny Prediction;743 filter = SpecTop; 744 checker = isAnySpeculation; 745 745 clobberWorld(node.codeOrigin, indexInBlock); 746 746 } 747 747 } else { 748 filter = PredictTop;749 checker = isAny Prediction;748 filter = SpecTop; 749 checker = isAnySpeculation; 750 750 clobberWorld(node.codeOrigin, indexInBlock); 751 751 } … … 767 767 break; 768 768 } 769 forNode(nodeIndex).set( PredictBoolean);769 forNode(nodeIndex).set(SpecBoolean); 770 770 if (m_graph.isJSConstant(node.child1().index())) { 771 771 JSValue value = m_graph.valueOfJSConstant(node.child1().index()); … … 795 795 m_graph[node.child1()], m_graph[node.child2()])) { 796 796 node.setCanExit( 797 !isFinalObject Prediction(forNode(node.child1()).m_type)798 || !isFinalObject Prediction(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); 801 801 break; 802 802 } … … 804 804 m_graph[node.child1()], m_graph[node.child2()])) { 805 805 node.setCanExit( 806 !isArray Prediction(forNode(node.child1()).m_type)807 || !isArray Prediction(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); 810 810 break; 811 811 } … … 816 816 case StringCharCodeAt: 817 817 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); 821 821 break; 822 822 823 823 case StringCharAt: 824 824 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); 828 828 break; 829 829 … … 834 834 break; 835 835 } 836 if (!isActionableArray Prediction(m_graph[node.child1()].prediction()) || !m_graph[node.child2()].shouldSpeculateInteger()) {836 if (!isActionableArraySpeculation(m_graph[node.child1()].prediction()) || !m_graph[node.child2()].shouldSpeculateInteger()) { 837 837 clobberWorld(node.codeOrigin, indexInBlock); 838 838 forNode(nodeIndex).makeTop(); … … 840 840 } 841 841 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); 844 844 forNode(nodeIndex).makeTop(); 845 845 break; 846 846 } 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); 851 851 break; 852 852 } 853 853 854 854 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); 858 858 break; 859 859 } 860 860 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); 864 864 break; 865 865 } 866 866 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); 870 870 break; 871 871 } 872 872 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); 876 876 break; 877 877 } 878 878 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); 882 882 break; 883 883 } 884 884 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); 888 888 break; 889 889 } 890 890 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); 893 893 if (node.shouldSpeculateInteger()) 894 forNode(nodeIndex).set( PredictInt32);894 forNode(nodeIndex).set(SpecInt32); 895 895 else 896 forNode(nodeIndex).set( PredictDouble);896 forNode(nodeIndex).set(SpecDouble); 897 897 break; 898 898 } 899 899 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); 903 903 break; 904 904 } 905 905 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); 909 909 break; 910 910 } 911 911 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); 914 914 forNode(nodeIndex).makeTop(); 915 915 break; … … 923 923 break; 924 924 } 925 if (!m_graph[node.child2()].shouldSpeculateInteger() || !isActionableMutableArray Prediction(m_graph[node.child1()].prediction())925 if (!m_graph[node.child2()].shouldSpeculateInteger() || !isActionableMutableArraySpeculation(m_graph[node.child1()].prediction()) 926 926 #if USE(JSVALUE32_64) 927 927 || m_graph[node.child1()].shouldSpeculateArguments() … … 935 935 936 936 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); 939 939 break; 940 940 } 941 941 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); 944 944 if (m_graph[node.child3()].shouldSpeculateInteger()) 945 forNode(node.child3()).filter( PredictInt32);945 forNode(node.child3()).filter(SpecInt32); 946 946 else 947 forNode(node.child3()).filter( PredictNumber);947 forNode(node.child3()).filter(SpecNumber); 948 948 break; 949 949 } 950 950 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); 953 953 if (m_graph[node.child3()].shouldSpeculateInteger()) 954 forNode(node.child3()).filter( PredictInt32);954 forNode(node.child3()).filter(SpecInt32); 955 955 else 956 forNode(node.child3()).filter( PredictNumber);956 forNode(node.child3()).filter(SpecNumber); 957 957 break; 958 958 } 959 959 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); 962 962 if (m_graph[node.child3()].shouldSpeculateInteger()) 963 forNode(node.child3()).filter( PredictInt32);963 forNode(node.child3()).filter(SpecInt32); 964 964 else 965 forNode(node.child3()).filter( PredictNumber);965 forNode(node.child3()).filter(SpecNumber); 966 966 break; 967 967 } 968 968 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); 971 971 if (m_graph[node.child3()].shouldSpeculateInteger()) 972 forNode(node.child3()).filter( PredictInt32);972 forNode(node.child3()).filter(SpecInt32); 973 973 else 974 forNode(node.child3()).filter( PredictNumber);974 forNode(node.child3()).filter(SpecNumber); 975 975 break; 976 976 } 977 977 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); 980 980 if (m_graph[node.child3()].shouldSpeculateInteger()) 981 forNode(node.child3()).filter( PredictInt32);981 forNode(node.child3()).filter(SpecInt32); 982 982 else 983 forNode(node.child3()).filter( PredictNumber);983 forNode(node.child3()).filter(SpecNumber); 984 984 break; 985 985 } 986 986 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); 989 989 if (m_graph[node.child3()].shouldSpeculateInteger()) 990 forNode(node.child3()).filter( PredictInt32);990 forNode(node.child3()).filter(SpecInt32); 991 991 else 992 forNode(node.child3()).filter( PredictNumber);992 forNode(node.child3()).filter(SpecNumber); 993 993 break; 994 994 } 995 995 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); 998 998 if (m_graph[node.child3()].shouldSpeculateInteger()) 999 forNode(node.child3()).filter( PredictInt32);999 forNode(node.child3()).filter(SpecInt32); 1000 1000 else 1001 forNode(node.child3()).filter( PredictNumber);1001 forNode(node.child3()).filter(SpecNumber); 1002 1002 break; 1003 1003 } 1004 1004 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); 1008 1008 break; 1009 1009 } 1010 1010 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); 1014 1014 break; 1015 1015 } 1016 1016 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); 1019 1019 if (node.op() == PutByVal) 1020 1020 clobberWorld(node.codeOrigin, indexInBlock); … … 1024 1024 case ArrayPush: 1025 1025 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); 1028 1028 break; 1029 1029 1030 1030 case ArrayPop: 1031 1031 node.setCanExit(true); 1032 forNode(node.child1()).filter( PredictArray);1032 forNode(node.child1()).filter(SpecArray); 1033 1033 forNode(nodeIndex).makeTop(); 1034 1034 break; … … 1037 1037 case RegExpTest: 1038 1038 node.setCanExit( 1039 !isCell Prediction(forNode(node.child1()).m_type)1040 || !isCell Prediction(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); 1043 1043 forNode(nodeIndex).makeTop(); 1044 1044 break; … … 1071 1071 else if (child.shouldSpeculateFinalObjectOrOther()) { 1072 1072 node.setCanExit( 1073 !isFinalObjectOrOther Prediction(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); 1075 1075 } else if (child.shouldSpeculateArrayOrOther()) { 1076 1076 node.setCanExit( 1077 !isArrayOrOther Prediction(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); 1079 1079 } else if (child.shouldSpeculateInteger()) 1080 1080 speculateInt32Unary(node); … … 1110 1110 if (child.shouldSpeculateInteger()) { 1111 1111 speculateInt32Unary(node); 1112 forNode(nodeIndex).set( PredictInt32);1112 forNode(nodeIndex).set(SpecInt32); 1113 1113 break; 1114 1114 } … … 1117 1117 AbstractValue& destination = forNode(nodeIndex); 1118 1118 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; 1123 1123 } 1124 1124 destination.set(type); … … 1129 1129 case StrCat: 1130 1130 node.setCanExit(false); 1131 forNode(nodeIndex).set( PredictString);1131 forNode(nodeIndex).set(SpecString); 1132 1132 break; 1133 1133 … … 1150 1150 AbstractValue& destination = forNode(nodeIndex); 1151 1151 1152 if (isObject Prediction(source.m_type)) {1152 if (isObjectSpeculation(source.m_type)) { 1153 1153 // This is the simple case. We already know that the source is an 1154 1154 // object, so there's nothing to do. I don't think this case will … … 1161 1161 node.setCanExit(true); 1162 1162 1163 if (isOther Prediction(child.prediction())) {1164 source.filter( PredictOther);1165 destination.set( PredictObjectOther);1166 break; 1167 } 1168 1169 if (isObject Prediction(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); 1171 1171 destination = source; 1172 1172 break; … … 1174 1174 1175 1175 destination = source; 1176 destination.merge( PredictObjectOther);1176 destination.merge(SpecObjectOther); 1177 1177 break; 1178 1178 } … … 1182 1182 AbstractValue& destination = forNode(nodeIndex); 1183 1183 1184 node.setCanExit(!isCell Prediction(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); 1188 1188 break; 1189 1189 } … … 1214 1214 1215 1215 case CheckArgumentsNotCreated: 1216 if (isEmpty Prediction(1216 if (isEmptySpeculation( 1217 1217 m_variables.operand( 1218 1218 m_graph.argumentsRegisterFor(node.codeOrigin)).m_type)) { … … 1231 1231 forNode(nodeIndex).set(jsNumber(node.codeOrigin.inlineCallFrame->arguments.size() - 1)); 1232 1232 else 1233 forNode(nodeIndex).set( PredictInt32);1233 forNode(nodeIndex).set(SpecInt32); 1234 1234 node.setCanExit( 1235 !isEmpty Prediction(1235 !isEmptySpeculation( 1236 1236 m_variables.operand( 1237 1237 m_graph.argumentsRegisterFor(node.codeOrigin)).m_type)); … … 1253 1253 // the arguments a bit. Note that this ends up being further optimized by the 1254 1254 // ArgumentsSimplificationPhase. 1255 forNode(node.child1()).filter( PredictInt32);1255 forNode(node.child1()).filter(SpecInt32); 1256 1256 forNode(nodeIndex).makeTop(); 1257 1257 break; … … 1263 1263 clobberWorld(node.codeOrigin, indexInBlock); 1264 1264 // But we do speculate that the index is an integer. 1265 forNode(node.child1()).filter( PredictInt32);1265 forNode(node.child1()).filter(SpecInt32); 1266 1266 // And the result is unknown. 1267 1267 forNode(nodeIndex).makeTop(); … … 1277 1277 case GetCallee: 1278 1278 node.setCanExit(false); 1279 forNode(nodeIndex).set( PredictFunction);1279 forNode(nodeIndex).set(SpecFunction); 1280 1280 break; 1281 1281 1282 1282 case GetScopeChain: 1283 1283 node.setCanExit(false); 1284 forNode(nodeIndex).set( PredictCellOther);1284 forNode(nodeIndex).set(SpecCellOther); 1285 1285 break; 1286 1286 … … 1302 1302 break; 1303 1303 } 1304 if (isCell Prediction(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); 1306 1306 clobberWorld(node.codeOrigin, indexInBlock); 1307 1307 forNode(nodeIndex).makeTop(); … … 1310 1310 case GetArrayLength: 1311 1311 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); 1314 1314 break; 1315 1315 1316 1316 case GetArgumentsLength: 1317 1317 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); 1320 1320 break; 1321 1321 1322 1322 case GetStringLength: 1323 node.setCanExit(!isString Prediction(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); 1326 1326 break; 1327 1327 1328 1328 case GetInt8ArrayLength: 1329 node.setCanExit(!isInt8Array Prediction(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); 1332 1332 break; 1333 1333 case GetInt16ArrayLength: 1334 node.setCanExit(!isInt16Array Prediction(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); 1337 1337 break; 1338 1338 case GetInt32ArrayLength: 1339 node.setCanExit(!isInt32Array Prediction(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); 1342 1342 break; 1343 1343 case GetUint8ArrayLength: 1344 node.setCanExit(!isUint8Array Prediction(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); 1347 1347 break; 1348 1348 case GetUint8ClampedArrayLength: 1349 node.setCanExit(!isUint8ClampedArray Prediction(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); 1352 1352 break; 1353 1353 case GetUint16ArrayLength: 1354 node.setCanExit(!isUint16Array Prediction(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); 1357 1357 break; 1358 1358 case GetUint32ArrayLength: 1359 node.setCanExit(!isUint32Array Prediction(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); 1362 1362 break; 1363 1363 case GetFloat32ArrayLength: 1364 node.setCanExit(!isFloat32Array Prediction(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); 1367 1367 break; 1368 1368 case GetFloat64ArrayLength: 1369 node.setCanExit(!isFloat64Array Prediction(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); 1372 1372 break; 1373 1373 … … 1377 1377 node.setCanExit( 1378 1378 !value.m_structure.isSubsetOf(node.structureSet()) 1379 || !isCell Prediction(value.m_type));1379 || !isCellSpeculation(value.m_type)); 1380 1380 value.filter(node.structureSet()); 1381 1381 m_haveStructures = true; … … 1392 1392 case GetPropertyStorage: 1393 1393 node.setCanExit(false); 1394 forNode(node.child1()).filter( PredictCell);1394 forNode(node.child1()).filter(SpecCell); 1395 1395 forNode(nodeIndex).clear(); // The result is not a JS value. 1396 1396 break; 1397 1397 case GetIndexedPropertyStorage: { 1398 1398 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) { 1401 1401 forNode(nodeIndex).clear(); 1402 1402 break; … … 1406 1406 break; 1407 1407 } 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); 1410 1410 forNode(nodeIndex).clear(); 1411 1411 break; … … 1413 1413 1414 1414 if (m_graph[node.child1()].shouldSpeculateInt8Array()) { 1415 forNode(node.child1()).filter( PredictInt8Array);1415 forNode(node.child1()).filter(SpecInt8Array); 1416 1416 forNode(nodeIndex).clear(); 1417 1417 break; 1418 1418 } 1419 1419 if (m_graph[node.child1()].shouldSpeculateInt16Array()) { 1420 forNode(node.child1()).filter( PredictInt16Array);1420 forNode(node.child1()).filter(SpecInt16Array); 1421 1421 forNode(nodeIndex).clear(); 1422 1422 break; 1423 1423 } 1424 1424 if (m_graph[node.child1()].shouldSpeculateInt32Array()) { 1425 forNode(node.child1()).filter( PredictInt32Array);1425 forNode(node.child1()).filter(SpecInt32Array); 1426 1426 forNode(nodeIndex).clear(); 1427 1427 break; 1428 1428 } 1429 1429 if (m_graph[node.child1()].shouldSpeculateUint8Array()) { 1430 forNode(node.child1()).filter( PredictUint8Array);1430 forNode(node.child1()).filter(SpecUint8Array); 1431 1431 forNode(nodeIndex).clear(); 1432 1432 break; 1433 1433 } 1434 1434 if (m_graph[node.child1()].shouldSpeculateUint8ClampedArray()) { 1435 forNode(node.child1()).filter( PredictUint8ClampedArray);1435 forNode(node.child1()).filter(SpecUint8ClampedArray); 1436 1436 forNode(nodeIndex).clear(); 1437 1437 break; 1438 1438 } 1439 1439 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); 1442 1442 break; 1443 1443 } 1444 1444 if (m_graph[node.child1()].shouldSpeculateUint32Array()) { 1445 forNode(node.child1()).filter( PredictUint32Array);1445 forNode(node.child1()).filter(SpecUint32Array); 1446 1446 forNode(nodeIndex).clear(); 1447 1447 break; 1448 1448 } 1449 1449 if (m_graph[node.child1()].shouldSpeculateFloat32Array()) { 1450 forNode(node.child1()).filter( PredictFloat32Array);1450 forNode(node.child1()).filter(SpecFloat32Array); 1451 1451 forNode(nodeIndex).clear(); 1452 1452 break; 1453 1453 } 1454 1454 if (m_graph[node.child1()].shouldSpeculateFloat64Array()) { 1455 forNode(node.child1()).filter( PredictFloat64Array);1455 forNode(node.child1()).filter(SpecFloat64Array); 1456 1456 forNode(nodeIndex).clear(); 1457 1457 break; 1458 1458 } 1459 forNode(node.child1()).filter( PredictArray);1459 forNode(node.child1()).filter(SpecArray); 1460 1460 forNode(nodeIndex).clear(); 1461 1461 break; … … 1463 1463 case GetByOffset: 1464 1464 node.setCanExit(false); 1465 forNode(node.child1()).filter( PredictCell);1465 forNode(node.child1()).filter(SpecCell); 1466 1466 forNode(nodeIndex).makeTop(); 1467 1467 break; … … 1469 1469 case PutByOffset: 1470 1470 node.setCanExit(false); 1471 forNode(node.child1()).filter( PredictCell);1471 forNode(node.child1()).filter(SpecCell); 1472 1472 break; 1473 1473 1474 1474 case CheckFunction: 1475 1475 node.setCanExit(true); // Lies! We can do better. 1476 forNode(node.child1()).filter( PredictFunction);1476 forNode(node.child1()).filter(SpecFunction); 1477 1477 // FIXME: Should be able to propagate the fact that we know what the function is. 1478 1478 break; … … 1481 1481 case PutByIdDirect: 1482 1482 node.setCanExit(true); 1483 forNode(node.child1()).filter( PredictCell);1483 forNode(node.child1()).filter(SpecCell); 1484 1484 clobberWorld(node.codeOrigin, indexInBlock); 1485 1485 break; … … 1496 1496 case CheckHasInstance: 1497 1497 node.setCanExit(true); 1498 forNode(node.child1()).filter( PredictCell);1498 forNode(node.child1()).filter(SpecCell); 1499 1499 // Sadly, we don't propagate the fact that we've done CheckHasInstance 1500 1500 break; … … 1503 1503 node.setCanExit(true); 1504 1504 // 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); 1509 1509 break; 1510 1510 … … 1632 1632 if (node.variableAccessData()->shouldUseDoubleFormat()) { 1633 1633 // FIXME: This unnecessarily loses precision. 1634 source.set( PredictDouble);1634 source.set(SpecDouble); 1635 1635 } else 1636 1636 source = forNode(node.child1());
Note:
See TracChangeset
for help on using the changeset viewer.