LCOV - code coverage report
Current view: top level - test/unittests/compiler - redundancy-elimination-unittest.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 618 632 97.8 %
Date: 2019-03-21 Functions: 102 152 67.1 %

          Line data    Source code
       1             : // Copyright 2018 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/compiler/redundancy-elimination.h"
       6             : #include "src/compiler/common-operator.h"
       7             : #include "test/unittests/compiler/graph-reducer-unittest.h"
       8             : #include "test/unittests/compiler/graph-unittest.h"
       9             : #include "test/unittests/compiler/node-test-utils.h"
      10             : #include "testing/gmock-support.h"
      11             : 
      12             : using testing::_;
      13             : using testing::NiceMock;
      14             : 
      15             : namespace v8 {
      16             : namespace internal {
      17             : namespace compiler {
      18             : namespace redundancy_elimination_unittest {
      19             : 
      20             : class RedundancyEliminationTest : public GraphTest {
      21             :  public:
      22          49 :   explicit RedundancyEliminationTest(int num_parameters = 4)
      23             :       : GraphTest(num_parameters),
      24             :         reducer_(&editor_, zone()),
      25         147 :         simplified_(zone()) {
      26             :     // Initialize the {reducer_} state for the Start node.
      27          49 :     reducer_.Reduce(graph()->start());
      28             : 
      29             :     // Create a feedback vector with two CALL_IC slots.
      30             :     FeedbackVectorSpec spec(zone());
      31             :     FeedbackSlot slot1 = spec.AddCallICSlot();
      32             :     FeedbackSlot slot2 = spec.AddCallICSlot();
      33          49 :     Handle<FeedbackMetadata> metadata = FeedbackMetadata::New(isolate(), &spec);
      34             :     Handle<SharedFunctionInfo> shared =
      35             :         isolate()->factory()->NewSharedFunctionInfoForBuiltin(
      36          49 :             isolate()->factory()->empty_string(), Builtins::kIllegal);
      37          98 :     shared->set_raw_outer_scope_info_or_feedback_metadata(*metadata);
      38             :     Handle<FixedArray> closure_feedback_cell_array =
      39          49 :         FeedbackVector::NewClosureFeedbackCellArray(isolate(), shared);
      40             :     Handle<FeedbackVector> feedback_vector =
      41          49 :         FeedbackVector::New(isolate(), shared, closure_feedback_cell_array);
      42          98 :     vector_slot_pairs_.push_back(VectorSlotPair());
      43          49 :     vector_slot_pairs_.push_back(
      44             :         VectorSlotPair(feedback_vector, slot1, UNINITIALIZED));
      45          49 :     vector_slot_pairs_.push_back(
      46             :         VectorSlotPair(feedback_vector, slot2, UNINITIALIZED));
      47          49 :   }
      48          98 :   ~RedundancyEliminationTest() override = default;
      49             : 
      50             :  protected:
      51        1158 :   Reduction Reduce(Node* node) { return reducer_.Reduce(node); }
      52             : 
      53             :   std::vector<VectorSlotPair> const& vector_slot_pairs() const {
      54             :     return vector_slot_pairs_;
      55             :   }
      56         552 :   SimplifiedOperatorBuilder* simplified() { return &simplified_; }
      57             : 
      58             :  private:
      59             :   NiceMock<MockAdvancedReducerEditor> editor_;
      60             :   std::vector<VectorSlotPair> vector_slot_pairs_;
      61             :   VectorSlotPair feedback2_;
      62             :   RedundancyElimination reducer_;
      63             :   SimplifiedOperatorBuilder simplified_;
      64             : };
      65             : 
      66             : namespace {
      67             : 
      68             : const CheckForMinusZeroMode kCheckForMinusZeroModes[] = {
      69             :     CheckForMinusZeroMode::kCheckForMinusZero,
      70             :     CheckForMinusZeroMode::kDontCheckForMinusZero,
      71             : };
      72             : 
      73             : const CheckTaggedInputMode kCheckTaggedInputModes[] = {
      74             :     CheckTaggedInputMode::kNumber, CheckTaggedInputMode::kNumberOrOddball};
      75             : 
      76             : const NumberOperationHint kNumberOperationHints[] = {
      77             :     NumberOperationHint::kSignedSmall,
      78             :     NumberOperationHint::kSignedSmallInputs,
      79             :     NumberOperationHint::kSigned32,
      80             :     NumberOperationHint::kNumber,
      81             :     NumberOperationHint::kNumberOrOddball,
      82             : };
      83             : 
      84             : }  // namespace
      85             : 
      86             : // -----------------------------------------------------------------------------
      87             : // CheckBounds
      88             : 
      89       15373 : TEST_F(RedundancyEliminationTest, CheckBounds) {
      90          10 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
      91          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
      92           9 :       Node* index = Parameter(0);
      93           9 :       Node* length = Parameter(1);
      94             :       Node* effect = graph()->start();
      95             :       Node* control = graph()->start();
      96             : 
      97           9 :       Node* check1 = effect = graph()->NewNode(
      98           9 :           simplified()->CheckBounds(feedback1), index, length, effect, control);
      99             :       Reduction r1 = Reduce(check1);
     100           9 :       ASSERT_TRUE(r1.Changed());
     101          18 :       EXPECT_EQ(r1.replacement(), check1);
     102             : 
     103           9 :       Node* check2 = effect = graph()->NewNode(
     104             :           simplified()->CheckBounds(feedback2), index, length, effect, control);
     105             :       Reduction r2 = Reduce(check2);
     106           9 :       ASSERT_TRUE(r2.Changed());
     107          18 :       EXPECT_EQ(r2.replacement(), check1);
     108             :     }
     109             :   }
     110             : }
     111             : 
     112             : // -----------------------------------------------------------------------------
     113             : // CheckNumber
     114             : 
     115       15373 : TEST_F(RedundancyEliminationTest, CheckNumberSubsumedByCheckSmi) {
     116          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     117          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     118           9 :       Node* value = Parameter(0);
     119             :       Node* effect = graph()->start();
     120             :       Node* control = graph()->start();
     121             : 
     122           9 :       Node* check1 = effect = graph()->NewNode(
     123           9 :           simplified()->CheckSmi(feedback1), value, effect, control);
     124             :       Reduction r1 = Reduce(check1);
     125           9 :       ASSERT_TRUE(r1.Changed());
     126          18 :       EXPECT_EQ(r1.replacement(), check1);
     127             : 
     128           9 :       Node* check2 = effect = graph()->NewNode(
     129             :           simplified()->CheckNumber(feedback2), value, effect, control);
     130             :       Reduction r2 = Reduce(check2);
     131           9 :       ASSERT_TRUE(r2.Changed());
     132          18 :       EXPECT_EQ(r2.replacement(), check1);
     133             :     }
     134             :   }
     135             : }
     136             : 
     137             : // -----------------------------------------------------------------------------
     138             : // CheckReceiver
     139             : 
     140       15373 : TEST_F(RedundancyEliminationTest, CheckReceiver) {
     141           1 :   Node* value = Parameter(0);
     142             :   Node* effect = graph()->start();
     143             :   Node* control = graph()->start();
     144             : 
     145             :   Node* check1 = effect =
     146           2 :       graph()->NewNode(simplified()->CheckReceiver(), value, effect, control);
     147             :   Reduction r1 = Reduce(check1);
     148           1 :   ASSERT_TRUE(r1.Changed());
     149           2 :   EXPECT_EQ(r1.replacement(), check1);
     150             : 
     151             :   Node* check2 = effect =
     152           1 :       graph()->NewNode(simplified()->CheckReceiver(), value, effect, control);
     153             :   Reduction r2 = Reduce(check2);
     154           1 :   ASSERT_TRUE(r2.Changed());
     155           2 :   EXPECT_EQ(r2.replacement(), check1);
     156             : }
     157             : 
     158             : // -----------------------------------------------------------------------------
     159             : // CheckReceiverOrNullOrUndefined
     160             : 
     161       15373 : TEST_F(RedundancyEliminationTest, CheckReceiverOrNullOrUndefined) {
     162           1 :   Node* value = Parameter(0);
     163             :   Node* effect = graph()->start();
     164             :   Node* control = graph()->start();
     165             : 
     166           1 :   Node* check1 = effect = graph()->NewNode(
     167           1 :       simplified()->CheckReceiverOrNullOrUndefined(), value, effect, control);
     168             :   Reduction r1 = Reduce(check1);
     169           1 :   ASSERT_TRUE(r1.Changed());
     170           2 :   EXPECT_EQ(r1.replacement(), check1);
     171             : 
     172           1 :   Node* check2 = effect = graph()->NewNode(
     173             :       simplified()->CheckReceiverOrNullOrUndefined(), value, effect, control);
     174             :   Reduction r2 = Reduce(check2);
     175           1 :   ASSERT_TRUE(r2.Changed());
     176           2 :   EXPECT_EQ(r2.replacement(), check1);
     177             : }
     178             : 
     179       15373 : TEST_F(RedundancyEliminationTest,
     180             :        CheckReceiverOrNullOrUndefinedSubsumedByCheckReceiver) {
     181           1 :   Node* value = Parameter(0);
     182             :   Node* effect = graph()->start();
     183             :   Node* control = graph()->start();
     184             : 
     185             :   Node* check1 = effect =
     186           2 :       graph()->NewNode(simplified()->CheckReceiver(), value, effect, control);
     187             :   Reduction r1 = Reduce(check1);
     188           1 :   ASSERT_TRUE(r1.Changed());
     189           2 :   EXPECT_EQ(r1.replacement(), check1);
     190             : 
     191           1 :   Node* check2 = effect = graph()->NewNode(
     192             :       simplified()->CheckReceiverOrNullOrUndefined(), value, effect, control);
     193             :   Reduction r2 = Reduce(check2);
     194           1 :   ASSERT_TRUE(r2.Changed());
     195           2 :   EXPECT_EQ(r2.replacement(), check1);
     196             : }
     197             : 
     198             : // -----------------------------------------------------------------------------
     199             : // CheckNonEmptyString
     200             : 
     201       15373 : TEST_F(RedundancyEliminationTest,
     202             :        CheckNonEmptyStringSubsumedByCheckNonEmptyOneByteString) {
     203           1 :   Node* value = Parameter(0);
     204             :   Node* effect = graph()->start();
     205             :   Node* control = graph()->start();
     206             : 
     207           1 :   Node* check1 = effect = graph()->NewNode(
     208           1 :       simplified()->CheckNonEmptyOneByteString(), value, effect, control);
     209             :   Reduction r1 = Reduce(check1);
     210           1 :   ASSERT_TRUE(r1.Changed());
     211           2 :   EXPECT_EQ(r1.replacement(), check1);
     212             : 
     213           1 :   Node* check2 = effect = graph()->NewNode(simplified()->CheckNonEmptyString(),
     214             :                                            value, effect, control);
     215             :   Reduction r2 = Reduce(check2);
     216           1 :   ASSERT_TRUE(r2.Changed());
     217           2 :   EXPECT_EQ(r2.replacement(), check1);
     218             : }
     219             : 
     220       15373 : TEST_F(RedundancyEliminationTest,
     221             :        CheckNonEmptyStringSubsumedByCheckNonEmptyTwoByteString) {
     222           1 :   Node* value = Parameter(0);
     223             :   Node* effect = graph()->start();
     224             :   Node* control = graph()->start();
     225             : 
     226           1 :   Node* check1 = effect = graph()->NewNode(
     227           1 :       simplified()->CheckNonEmptyTwoByteString(), value, effect, control);
     228             :   Reduction r1 = Reduce(check1);
     229           1 :   ASSERT_TRUE(r1.Changed());
     230           2 :   EXPECT_EQ(r1.replacement(), check1);
     231             : 
     232           1 :   Node* check2 = effect = graph()->NewNode(simplified()->CheckNonEmptyString(),
     233             :                                            value, effect, control);
     234             :   Reduction r2 = Reduce(check2);
     235           1 :   ASSERT_TRUE(r2.Changed());
     236           2 :   EXPECT_EQ(r2.replacement(), check1);
     237             : }
     238             : 
     239             : // -----------------------------------------------------------------------------
     240             : // CheckString
     241             : 
     242       15373 : TEST_F(RedundancyEliminationTest,
     243             :        CheckStringSubsumedByCheckInternalizedString) {
     244          13 :   TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
     245           3 :     Node* value = Parameter(0);
     246             :     Node* effect = graph()->start();
     247             :     Node* control = graph()->start();
     248             : 
     249           3 :     Node* check1 = effect = graph()->NewNode(
     250           3 :         simplified()->CheckInternalizedString(), value, effect, control);
     251             :     Reduction r1 = Reduce(check1);
     252           3 :     ASSERT_TRUE(r1.Changed());
     253           6 :     EXPECT_EQ(r1.replacement(), check1);
     254             : 
     255           3 :     Node* check2 = effect = graph()->NewNode(
     256             :         simplified()->CheckString(feedback), value, effect, control);
     257             :     Reduction r2 = Reduce(check2);
     258           3 :     ASSERT_TRUE(r2.Changed());
     259           6 :     EXPECT_EQ(r2.replacement(), check1);
     260             :   }
     261             : }
     262             : 
     263       15373 : TEST_F(RedundancyEliminationTest, CheckStringSubsumedByCheckNonEmptyString) {
     264          13 :   TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
     265           3 :     Node* value = Parameter(0);
     266             :     Node* effect = graph()->start();
     267             :     Node* control = graph()->start();
     268             : 
     269           3 :     Node* check1 = effect = graph()->NewNode(
     270           3 :         simplified()->CheckNonEmptyString(), value, effect, control);
     271             :     Reduction r1 = Reduce(check1);
     272           3 :     ASSERT_TRUE(r1.Changed());
     273           6 :     EXPECT_EQ(r1.replacement(), check1);
     274             : 
     275           3 :     Node* check2 = effect = graph()->NewNode(
     276             :         simplified()->CheckString(feedback), value, effect, control);
     277             :     Reduction r2 = Reduce(check2);
     278           3 :     ASSERT_TRUE(r2.Changed());
     279           6 :     EXPECT_EQ(r2.replacement(), check1);
     280             :   }
     281             : }
     282             : 
     283       15373 : TEST_F(RedundancyEliminationTest,
     284             :        CheckStringSubsumedByCheckNonEmptyOneByteString) {
     285          13 :   TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
     286           3 :     Node* value = Parameter(0);
     287             :     Node* effect = graph()->start();
     288             :     Node* control = graph()->start();
     289             : 
     290           3 :     Node* check1 = effect = graph()->NewNode(
     291           3 :         simplified()->CheckNonEmptyOneByteString(), value, effect, control);
     292             :     Reduction r1 = Reduce(check1);
     293           3 :     ASSERT_TRUE(r1.Changed());
     294           6 :     EXPECT_EQ(r1.replacement(), check1);
     295             : 
     296           3 :     Node* check2 = effect = graph()->NewNode(
     297             :         simplified()->CheckString(feedback), value, effect, control);
     298             :     Reduction r2 = Reduce(check2);
     299           3 :     ASSERT_TRUE(r2.Changed());
     300           6 :     EXPECT_EQ(r2.replacement(), check1);
     301             :   }
     302             : }
     303             : 
     304       15373 : TEST_F(RedundancyEliminationTest,
     305             :        CheckStringSubsumedByCheckNonEmptyTwoByteString) {
     306          13 :   TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
     307           3 :     Node* value = Parameter(0);
     308             :     Node* effect = graph()->start();
     309             :     Node* control = graph()->start();
     310             : 
     311           3 :     Node* check1 = effect = graph()->NewNode(
     312           3 :         simplified()->CheckNonEmptyTwoByteString(), value, effect, control);
     313             :     Reduction r1 = Reduce(check1);
     314           3 :     ASSERT_TRUE(r1.Changed());
     315           6 :     EXPECT_EQ(r1.replacement(), check1);
     316             : 
     317           3 :     Node* check2 = effect = graph()->NewNode(
     318             :         simplified()->CheckString(feedback), value, effect, control);
     319             :     Reduction r2 = Reduce(check2);
     320           3 :     ASSERT_TRUE(r2.Changed());
     321           6 :     EXPECT_EQ(r2.replacement(), check1);
     322             :   }
     323             : }
     324             : 
     325             : // -----------------------------------------------------------------------------
     326             : // CheckSymbol
     327             : 
     328       15373 : TEST_F(RedundancyEliminationTest, CheckSymbol) {
     329           1 :   Node* value = Parameter(0);
     330             :   Node* effect = graph()->start();
     331             :   Node* control = graph()->start();
     332             : 
     333             :   Node* check1 = effect =
     334           2 :       graph()->NewNode(simplified()->CheckSymbol(), value, effect, control);
     335             :   Reduction r1 = Reduce(check1);
     336           1 :   ASSERT_TRUE(r1.Changed());
     337           2 :   EXPECT_EQ(r1.replacement(), check1);
     338             : 
     339             :   Node* check2 = effect =
     340           1 :       graph()->NewNode(simplified()->CheckSymbol(), value, effect, control);
     341             :   Reduction r2 = Reduce(check2);
     342           1 :   ASSERT_TRUE(r2.Changed());
     343           2 :   EXPECT_EQ(r2.replacement(), check1);
     344             : }
     345             : 
     346             : // -----------------------------------------------------------------------------
     347             : // CheckedFloat64ToInt32
     348             : 
     349       15373 : TEST_F(RedundancyEliminationTest, CheckedFloat64ToInt32) {
     350          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     351          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     352          81 :       TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) {
     353          18 :         Node* value = Parameter(0);
     354             :         Node* effect = graph()->start();
     355             :         Node* control = graph()->start();
     356             : 
     357          18 :         Node* check1 = effect = graph()->NewNode(
     358             :             simplified()->CheckedFloat64ToInt32(mode, feedback1), value, effect,
     359          18 :             control);
     360             :         Reduction r1 = Reduce(check1);
     361          18 :         ASSERT_TRUE(r1.Changed());
     362          36 :         EXPECT_EQ(r1.replacement(), check1);
     363             : 
     364          18 :         Node* check2 = effect = graph()->NewNode(
     365             :             simplified()->CheckedFloat64ToInt32(mode, feedback2), value, effect,
     366             :             control);
     367             :         Reduction r2 = Reduce(check2);
     368          18 :         ASSERT_TRUE(r2.Changed());
     369          36 :         EXPECT_EQ(r2.replacement(), check1);
     370             :       }
     371             :     }
     372             :   }
     373             : }
     374             : 
     375             : // -----------------------------------------------------------------------------
     376             : // CheckedFloat64ToInt64
     377             : 
     378       15373 : TEST_F(RedundancyEliminationTest, CheckedFloat64ToInt64) {
     379          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     380          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     381          81 :       TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) {
     382          18 :         Node* value = Parameter(0);
     383             :         Node* effect = graph()->start();
     384             :         Node* control = graph()->start();
     385             : 
     386          18 :         Node* check1 = effect = graph()->NewNode(
     387             :             simplified()->CheckedFloat64ToInt64(mode, feedback1), value, effect,
     388          18 :             control);
     389             :         Reduction r1 = Reduce(check1);
     390          18 :         ASSERT_TRUE(r1.Changed());
     391          36 :         EXPECT_EQ(r1.replacement(), check1);
     392             : 
     393          18 :         Node* check2 = effect = graph()->NewNode(
     394             :             simplified()->CheckedFloat64ToInt64(mode, feedback2), value, effect,
     395             :             control);
     396             :         Reduction r2 = Reduce(check2);
     397          18 :         ASSERT_TRUE(r2.Changed());
     398          36 :         EXPECT_EQ(r2.replacement(), check1);
     399             :       }
     400             :     }
     401             :   }
     402             : }
     403             : 
     404             : // -----------------------------------------------------------------------------
     405             : // CheckedInt32ToTaggedSigned
     406             : 
     407       15373 : TEST_F(RedundancyEliminationTest, CheckedInt32ToTaggedSigned) {
     408          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     409          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     410           9 :       Node* value = Parameter(0);
     411             :       Node* effect = graph()->start();
     412             :       Node* control = graph()->start();
     413             : 
     414             :       Node* check1 = effect =
     415           9 :           graph()->NewNode(simplified()->CheckedInt32ToTaggedSigned(feedback1),
     416           9 :                            value, effect, control);
     417             :       Reduction r1 = Reduce(check1);
     418           9 :       ASSERT_TRUE(r1.Changed());
     419          18 :       EXPECT_EQ(r1.replacement(), check1);
     420             : 
     421             :       Node* check2 = effect =
     422           9 :           graph()->NewNode(simplified()->CheckedInt32ToTaggedSigned(feedback2),
     423             :                            value, effect, control);
     424             :       Reduction r2 = Reduce(check2);
     425           9 :       ASSERT_TRUE(r2.Changed());
     426          18 :       EXPECT_EQ(r2.replacement(), check1);
     427             :     }
     428             :   }
     429             : }
     430             : 
     431             : // -----------------------------------------------------------------------------
     432             : // CheckedInt64ToInt32
     433             : 
     434       15373 : TEST_F(RedundancyEliminationTest, CheckedInt64ToInt32) {
     435          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     436          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     437           9 :       Node* value = Parameter(0);
     438             :       Node* effect = graph()->start();
     439             :       Node* control = graph()->start();
     440             : 
     441           9 :       Node* check1 = effect = graph()->NewNode(
     442           9 :           simplified()->CheckedInt64ToInt32(feedback1), value, effect, control);
     443             :       Reduction r1 = Reduce(check1);
     444           9 :       ASSERT_TRUE(r1.Changed());
     445          18 :       EXPECT_EQ(r1.replacement(), check1);
     446             : 
     447           9 :       Node* check2 = effect = graph()->NewNode(
     448             :           simplified()->CheckedInt64ToInt32(feedback2), value, effect, control);
     449             :       Reduction r2 = Reduce(check2);
     450           9 :       ASSERT_TRUE(r2.Changed());
     451          18 :       EXPECT_EQ(r2.replacement(), check1);
     452             :     }
     453             :   }
     454             : }
     455             : 
     456             : // -----------------------------------------------------------------------------
     457             : // CheckedInt64ToTaggedSigned
     458             : 
     459       12299 : TEST_F(RedundancyEliminationTest, CheckedInt64ToTaggedSigned) {
     460          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     461          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     462           9 :       Node* value = Parameter(0);
     463             :       Node* effect = graph()->start();
     464             :       Node* control = graph()->start();
     465             : 
     466             :       Node* check1 = effect =
     467           9 :           graph()->NewNode(simplified()->CheckedInt64ToTaggedSigned(feedback1),
     468           9 :                            value, effect, control);
     469             :       Reduction r1 = Reduce(check1);
     470           9 :       ASSERT_TRUE(r1.Changed());
     471          18 :       EXPECT_EQ(r1.replacement(), check1);
     472             : 
     473             :       Node* check2 = effect =
     474           9 :           graph()->NewNode(simplified()->CheckedInt64ToTaggedSigned(feedback2),
     475             :                            value, effect, control);
     476             :       Reduction r2 = Reduce(check2);
     477           9 :       ASSERT_TRUE(r2.Changed());
     478          18 :       EXPECT_EQ(r2.replacement(), check1);
     479             :     }
     480             :   }
     481             : }
     482             : 
     483             : // -----------------------------------------------------------------------------
     484             : // CheckedTaggedSignedToInt32
     485             : 
     486       15373 : TEST_F(RedundancyEliminationTest, CheckedTaggedSignedToInt32) {
     487          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     488          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     489           9 :       Node* value = Parameter(0);
     490             :       Node* effect = graph()->start();
     491             :       Node* control = graph()->start();
     492             : 
     493             :       Node* check1 = effect =
     494           9 :           graph()->NewNode(simplified()->CheckedTaggedSignedToInt32(feedback1),
     495           9 :                            value, effect, control);
     496             :       Reduction r1 = Reduce(check1);
     497           9 :       ASSERT_TRUE(r1.Changed());
     498          18 :       EXPECT_EQ(r1.replacement(), check1);
     499             : 
     500             :       Node* check2 = effect =
     501           9 :           graph()->NewNode(simplified()->CheckedTaggedSignedToInt32(feedback2),
     502             :                            value, effect, control);
     503             :       Reduction r2 = Reduce(check2);
     504           9 :       ASSERT_TRUE(r2.Changed());
     505          18 :       EXPECT_EQ(r2.replacement(), check1);
     506             :     }
     507             :   }
     508             : }
     509             : 
     510             : // -----------------------------------------------------------------------------
     511             : // CheckedTaggedToFloat64
     512             : 
     513       15373 : TEST_F(RedundancyEliminationTest, CheckedTaggedToFloat64) {
     514          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     515          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     516          81 :       TRACED_FOREACH(CheckTaggedInputMode, mode, kCheckTaggedInputModes) {
     517          18 :         Node* value = Parameter(0);
     518             :         Node* effect = graph()->start();
     519             :         Node* control = graph()->start();
     520             : 
     521          18 :         Node* check1 = effect = graph()->NewNode(
     522             :             simplified()->CheckedTaggedToFloat64(mode, feedback1), value,
     523          18 :             effect, control);
     524             :         Reduction r1 = Reduce(check1);
     525          18 :         ASSERT_TRUE(r1.Changed());
     526          36 :         EXPECT_EQ(r1.replacement(), check1);
     527             : 
     528          18 :         Node* check2 = effect = graph()->NewNode(
     529             :             simplified()->CheckedTaggedToFloat64(mode, feedback2), value,
     530             :             effect, control);
     531             :         Reduction r2 = Reduce(check2);
     532          18 :         ASSERT_TRUE(r2.Changed());
     533          36 :         EXPECT_EQ(r2.replacement(), check1);
     534             :       }
     535             :     }
     536             :   }
     537             : }
     538             : 
     539       15373 : TEST_F(RedundancyEliminationTest,
     540             :        CheckedTaggedToFloat64SubsubmedByCheckedTaggedToFloat64) {
     541          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     542          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     543           9 :       Node* value = Parameter(0);
     544             :       Node* effect = graph()->start();
     545             :       Node* control = graph()->start();
     546             : 
     547             :       // If the check passed for CheckTaggedInputMode::kNumber, it'll
     548             :       // also pass later for CheckTaggedInputMode::kNumberOrOddball.
     549             :       Node* check1 = effect =
     550           9 :           graph()->NewNode(simplified()->CheckedTaggedToFloat64(
     551             :                                CheckTaggedInputMode::kNumber, feedback1),
     552           9 :                            value, effect, control);
     553             :       Reduction r1 = Reduce(check1);
     554           9 :       ASSERT_TRUE(r1.Changed());
     555          18 :       EXPECT_EQ(r1.replacement(), check1);
     556             : 
     557           9 :       Node* check2 = effect = graph()->NewNode(
     558             :           simplified()->CheckedTaggedToFloat64(
     559             :               CheckTaggedInputMode::kNumberOrOddball, feedback2),
     560             :           value, effect, control);
     561             :       Reduction r2 = Reduce(check2);
     562           9 :       ASSERT_TRUE(r2.Changed());
     563          18 :       EXPECT_EQ(r2.replacement(), check1);
     564             :     }
     565             :   }
     566             : }
     567             : 
     568             : // -----------------------------------------------------------------------------
     569             : // CheckedTaggedToInt32
     570             : 
     571       15373 : TEST_F(RedundancyEliminationTest, CheckedTaggedToInt32) {
     572          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     573          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     574          81 :       TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) {
     575          18 :         Node* value = Parameter(0);
     576             :         Node* effect = graph()->start();
     577             :         Node* control = graph()->start();
     578             : 
     579          18 :         Node* check1 = effect = graph()->NewNode(
     580             :             simplified()->CheckedTaggedToInt32(mode, feedback1), value, effect,
     581          18 :             control);
     582             :         Reduction r1 = Reduce(check1);
     583          18 :         ASSERT_TRUE(r1.Changed());
     584          36 :         EXPECT_EQ(r1.replacement(), check1);
     585             : 
     586          18 :         Node* check2 = effect = graph()->NewNode(
     587             :             simplified()->CheckedTaggedToInt32(mode, feedback2), value, effect,
     588             :             control);
     589             :         Reduction r2 = Reduce(check2);
     590          18 :         ASSERT_TRUE(r2.Changed());
     591          36 :         EXPECT_EQ(r2.replacement(), check1);
     592             :       }
     593             :     }
     594             :   }
     595             : }
     596             : 
     597       15373 : TEST_F(RedundancyEliminationTest,
     598             :        CheckedTaggedToInt32SubsumedByCheckedTaggedSignedToInt32) {
     599          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     600          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     601          81 :       TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) {
     602          18 :         Node* value = Parameter(0);
     603             :         Node* effect = graph()->start();
     604             :         Node* control = graph()->start();
     605             : 
     606          18 :         Node* check1 = effect = graph()->NewNode(
     607             :             simplified()->CheckedTaggedSignedToInt32(feedback1), value, effect,
     608          18 :             control);
     609             :         Reduction r1 = Reduce(check1);
     610          18 :         ASSERT_TRUE(r1.Changed());
     611          36 :         EXPECT_EQ(r1.replacement(), check1);
     612             : 
     613          18 :         Node* check2 = effect = graph()->NewNode(
     614             :             simplified()->CheckedTaggedToInt32(mode, feedback2), value, effect,
     615             :             control);
     616             :         Reduction r2 = Reduce(check2);
     617          18 :         ASSERT_TRUE(r2.Changed());
     618          36 :         EXPECT_EQ(r2.replacement(), check1);
     619             :       }
     620             :     }
     621             :   }
     622             : }
     623             : 
     624             : // -----------------------------------------------------------------------------
     625             : // CheckedTaggedToInt64
     626             : 
     627       15373 : TEST_F(RedundancyEliminationTest, CheckedTaggedToInt64) {
     628          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     629          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     630          81 :       TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) {
     631          18 :         Node* value = Parameter(0);
     632             :         Node* effect = graph()->start();
     633             :         Node* control = graph()->start();
     634             : 
     635          18 :         Node* check1 = effect = graph()->NewNode(
     636             :             simplified()->CheckedTaggedToInt64(mode, feedback1), value, effect,
     637          18 :             control);
     638             :         Reduction r1 = Reduce(check1);
     639          18 :         ASSERT_TRUE(r1.Changed());
     640          36 :         EXPECT_EQ(r1.replacement(), check1);
     641             : 
     642          18 :         Node* check2 = effect = graph()->NewNode(
     643             :             simplified()->CheckedTaggedToInt64(mode, feedback2), value, effect,
     644             :             control);
     645             :         Reduction r2 = Reduce(check2);
     646          18 :         ASSERT_TRUE(r2.Changed());
     647          36 :         EXPECT_EQ(r2.replacement(), check1);
     648             :       }
     649             :     }
     650             :   }
     651             : }
     652             : 
     653             : // -----------------------------------------------------------------------------
     654             : // CheckedTaggedToTaggedPointer
     655             : 
     656       15373 : TEST_F(RedundancyEliminationTest, CheckedTaggedToTaggedPointer) {
     657          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     658          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     659           9 :       Node* value = Parameter(0);
     660             :       Node* effect = graph()->start();
     661             :       Node* control = graph()->start();
     662             : 
     663           9 :       Node* check1 = effect = graph()->NewNode(
     664             :           simplified()->CheckedTaggedToTaggedPointer(feedback1), value, effect,
     665           9 :           control);
     666             :       Reduction r1 = Reduce(check1);
     667           9 :       ASSERT_TRUE(r1.Changed());
     668          18 :       EXPECT_EQ(r1.replacement(), check1);
     669             : 
     670           9 :       Node* check2 = effect = graph()->NewNode(
     671             :           simplified()->CheckedTaggedToTaggedPointer(feedback2), value, effect,
     672             :           control);
     673             :       Reduction r2 = Reduce(check2);
     674           9 :       ASSERT_TRUE(r2.Changed());
     675          18 :       EXPECT_EQ(r2.replacement(), check1);
     676             :     }
     677             :   }
     678             : }
     679             : 
     680             : // -----------------------------------------------------------------------------
     681             : // CheckedTaggedToTaggedSigned
     682             : 
     683       15373 : TEST_F(RedundancyEliminationTest, CheckedTaggedToTaggedSigned) {
     684          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     685          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     686           9 :       Node* value = Parameter(0);
     687             :       Node* effect = graph()->start();
     688             :       Node* control = graph()->start();
     689             : 
     690             :       Node* check1 = effect =
     691           9 :           graph()->NewNode(simplified()->CheckedTaggedToTaggedSigned(feedback1),
     692           9 :                            value, effect, control);
     693             :       Reduction r1 = Reduce(check1);
     694           9 :       ASSERT_TRUE(r1.Changed());
     695          18 :       EXPECT_EQ(r1.replacement(), check1);
     696             : 
     697             :       Node* check2 = effect =
     698           9 :           graph()->NewNode(simplified()->CheckedTaggedToTaggedSigned(feedback2),
     699             :                            value, effect, control);
     700             :       Reduction r2 = Reduce(check2);
     701           9 :       ASSERT_TRUE(r2.Changed());
     702          18 :       EXPECT_EQ(r2.replacement(), check1);
     703             :     }
     704             :   }
     705             : }
     706             : 
     707             : // -----------------------------------------------------------------------------
     708             : // CheckedTruncateTaggedToWord32
     709             : 
     710       15373 : TEST_F(RedundancyEliminationTest, CheckedTruncateTaggedToWord32) {
     711          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     712          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     713          81 :       TRACED_FOREACH(CheckTaggedInputMode, mode, kCheckTaggedInputModes) {
     714          18 :         Node* value = Parameter(0);
     715             :         Node* effect = graph()->start();
     716             :         Node* control = graph()->start();
     717             : 
     718          18 :         Node* check1 = effect = graph()->NewNode(
     719             :             simplified()->CheckedTruncateTaggedToWord32(mode, feedback1), value,
     720          18 :             effect, control);
     721             :         Reduction r1 = Reduce(check1);
     722          18 :         ASSERT_TRUE(r1.Changed());
     723          36 :         EXPECT_EQ(r1.replacement(), check1);
     724             : 
     725          18 :         Node* check2 = effect = graph()->NewNode(
     726             :             simplified()->CheckedTruncateTaggedToWord32(mode, feedback2), value,
     727             :             effect, control);
     728             :         Reduction r2 = Reduce(check2);
     729          18 :         ASSERT_TRUE(r2.Changed());
     730          36 :         EXPECT_EQ(r2.replacement(), check1);
     731             :       }
     732             :     }
     733             :   }
     734             : }
     735             : 
     736       15373 : TEST_F(RedundancyEliminationTest,
     737             :        CheckedTruncateTaggedToWord32SubsumedByCheckedTruncateTaggedToWord32) {
     738          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     739          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     740           9 :       Node* value = Parameter(0);
     741             :       Node* effect = graph()->start();
     742             :       Node* control = graph()->start();
     743             : 
     744             :       // If the check passed for CheckTaggedInputMode::kNumber, it'll
     745             :       // also pass later for CheckTaggedInputMode::kNumberOrOddball.
     746             :       Node* check1 = effect =
     747           9 :           graph()->NewNode(simplified()->CheckedTruncateTaggedToWord32(
     748             :                                CheckTaggedInputMode::kNumber, feedback1),
     749           9 :                            value, effect, control);
     750             :       Reduction r1 = Reduce(check1);
     751           9 :       ASSERT_TRUE(r1.Changed());
     752          18 :       EXPECT_EQ(r1.replacement(), check1);
     753             : 
     754           9 :       Node* check2 = effect = graph()->NewNode(
     755             :           simplified()->CheckedTruncateTaggedToWord32(
     756             :               CheckTaggedInputMode::kNumberOrOddball, feedback2),
     757             :           value, effect, control);
     758             :       Reduction r2 = Reduce(check2);
     759           9 :       ASSERT_TRUE(r2.Changed());
     760          18 :       EXPECT_EQ(r2.replacement(), check1);
     761             :     }
     762             :   }
     763             : }
     764             : 
     765             : // -----------------------------------------------------------------------------
     766             : // CheckedUint32Bounds
     767             : 
     768       15373 : TEST_F(RedundancyEliminationTest, CheckedUint32Bounds) {
     769          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     770          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     771           9 :       Node* index = Parameter(0);
     772           9 :       Node* length = Parameter(1);
     773             :       Node* effect = graph()->start();
     774             :       Node* control = graph()->start();
     775             : 
     776           9 :       Node* check1 = effect = graph()->NewNode(
     777             :           simplified()->CheckedUint32Bounds(
     778             :               feedback1, CheckBoundsParameters::kDeoptOnOutOfBounds),
     779           9 :           index, length, effect, control);
     780             :       Reduction r1 = Reduce(check1);
     781           9 :       ASSERT_TRUE(r1.Changed());
     782          18 :       EXPECT_EQ(r1.replacement(), check1);
     783             : 
     784           9 :       Node* check2 = effect = graph()->NewNode(
     785             :           simplified()->CheckedUint32Bounds(
     786             :               feedback2, CheckBoundsParameters::kDeoptOnOutOfBounds),
     787             :           index, length, effect, control);
     788             :       Reduction r2 = Reduce(check2);
     789           9 :       ASSERT_TRUE(r2.Changed());
     790          18 :       EXPECT_EQ(r2.replacement(), check1);
     791             :     }
     792             :   }
     793             : }
     794             : 
     795             : // -----------------------------------------------------------------------------
     796             : // CheckedUint32ToInt32
     797             : 
     798       15373 : TEST_F(RedundancyEliminationTest, CheckedUint32ToInt32) {
     799          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     800          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     801           9 :       Node* value = Parameter(0);
     802             :       Node* effect = graph()->start();
     803             :       Node* control = graph()->start();
     804             : 
     805             :       Node* check1 = effect =
     806           9 :           graph()->NewNode(simplified()->CheckedUint32ToInt32(feedback1), value,
     807           9 :                            effect, control);
     808             :       Reduction r1 = Reduce(check1);
     809           9 :       ASSERT_TRUE(r1.Changed());
     810          18 :       EXPECT_EQ(r1.replacement(), check1);
     811             : 
     812             :       Node* check2 = effect =
     813           9 :           graph()->NewNode(simplified()->CheckedUint32ToInt32(feedback2), value,
     814             :                            effect, control);
     815             :       Reduction r2 = Reduce(check2);
     816           9 :       ASSERT_TRUE(r2.Changed());
     817          18 :       EXPECT_EQ(r2.replacement(), check1);
     818             :     }
     819             :   }
     820             : }
     821             : 
     822             : // -----------------------------------------------------------------------------
     823             : // CheckedUint32ToTaggedSigned
     824             : 
     825       15373 : TEST_F(RedundancyEliminationTest, CheckedUint32ToTaggedSigned) {
     826          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     827          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     828           9 :       Node* value = Parameter(0);
     829             :       Node* effect = graph()->start();
     830             :       Node* control = graph()->start();
     831             : 
     832             :       Node* check1 = effect =
     833           9 :           graph()->NewNode(simplified()->CheckedUint32ToTaggedSigned(feedback1),
     834           9 :                            value, effect, control);
     835             :       Reduction r1 = Reduce(check1);
     836           9 :       ASSERT_TRUE(r1.Changed());
     837          18 :       EXPECT_EQ(r1.replacement(), check1);
     838             : 
     839             :       Node* check2 = effect =
     840           9 :           graph()->NewNode(simplified()->CheckedUint32ToTaggedSigned(feedback2),
     841             :                            value, effect, control);
     842             :       Reduction r2 = Reduce(check2);
     843           9 :       ASSERT_TRUE(r2.Changed());
     844          18 :       EXPECT_EQ(r2.replacement(), check1);
     845             :     }
     846             :   }
     847             : }
     848             : 
     849             : // -----------------------------------------------------------------------------
     850             : // CheckedUint64Bounds
     851             : 
     852       15373 : TEST_F(RedundancyEliminationTest, CheckedUint64Bounds) {
     853          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     854          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     855           9 :       Node* index = Parameter(0);
     856           9 :       Node* length = Parameter(1);
     857             :       Node* effect = graph()->start();
     858             :       Node* control = graph()->start();
     859             : 
     860             :       Node* check1 = effect =
     861           9 :           graph()->NewNode(simplified()->CheckedUint64Bounds(feedback1), index,
     862           9 :                            length, effect, control);
     863             :       Reduction r1 = Reduce(check1);
     864           9 :       ASSERT_TRUE(r1.Changed());
     865          18 :       EXPECT_EQ(r1.replacement(), check1);
     866             : 
     867             :       Node* check2 = effect =
     868           9 :           graph()->NewNode(simplified()->CheckedUint64Bounds(feedback2), index,
     869             :                            length, effect, control);
     870             :       Reduction r2 = Reduce(check2);
     871           9 :       ASSERT_TRUE(r2.Changed());
     872          18 :       EXPECT_EQ(r2.replacement(), check1);
     873             :     }
     874             :   }
     875             : }
     876             : 
     877             : // -----------------------------------------------------------------------------
     878             : // CheckedUint64ToInt32
     879             : 
     880       15373 : TEST_F(RedundancyEliminationTest, CheckedUint64ToInt32) {
     881          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     882          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     883           9 :       Node* value = Parameter(0);
     884             :       Node* effect = graph()->start();
     885             :       Node* control = graph()->start();
     886             : 
     887             :       Node* check1 = effect =
     888           9 :           graph()->NewNode(simplified()->CheckedUint64ToInt32(feedback1), value,
     889           9 :                            effect, control);
     890             :       Reduction r1 = Reduce(check1);
     891           9 :       ASSERT_TRUE(r1.Changed());
     892          18 :       EXPECT_EQ(r1.replacement(), check1);
     893             : 
     894             :       Node* check2 = effect =
     895           9 :           graph()->NewNode(simplified()->CheckedUint64ToInt32(feedback2), value,
     896             :                            effect, control);
     897             :       Reduction r2 = Reduce(check2);
     898           9 :       ASSERT_TRUE(r2.Changed());
     899          18 :       EXPECT_EQ(r2.replacement(), check1);
     900             :     }
     901             :   }
     902             : }
     903             : 
     904             : // -----------------------------------------------------------------------------
     905             : // CheckedUint64ToTaggedSigned
     906             : 
     907       15373 : TEST_F(RedundancyEliminationTest, CheckedUint64ToTaggedSigned) {
     908          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     909          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     910           9 :       Node* value = Parameter(0);
     911             :       Node* effect = graph()->start();
     912             :       Node* control = graph()->start();
     913             : 
     914             :       Node* check1 = effect =
     915           9 :           graph()->NewNode(simplified()->CheckedUint64ToTaggedSigned(feedback1),
     916           9 :                            value, effect, control);
     917             :       Reduction r1 = Reduce(check1);
     918           9 :       ASSERT_TRUE(r1.Changed());
     919          18 :       EXPECT_EQ(r1.replacement(), check1);
     920             : 
     921             :       Node* check2 = effect =
     922           9 :           graph()->NewNode(simplified()->CheckedUint64ToTaggedSigned(feedback2),
     923             :                            value, effect, control);
     924             :       Reduction r2 = Reduce(check2);
     925           9 :       ASSERT_TRUE(r2.Changed());
     926          18 :       EXPECT_EQ(r2.replacement(), check1);
     927             :     }
     928             :   }
     929             : }
     930             : 
     931             : // -----------------------------------------------------------------------------
     932             : // SpeculativeNumberEqual
     933             : 
     934       15373 : TEST_F(RedundancyEliminationTest,
     935             :        SpeculativeNumberEqualWithCheckBoundsBetterType) {
     936           2 :   Typer typer(broker(), Typer::kNoFlags, graph());
     937          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     938          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     939           9 :       Node* lhs = Parameter(Type::Any(), 0);
     940           9 :       Node* rhs = Parameter(Type::Any(), 1);
     941           9 :       Node* length = Parameter(Type::Unsigned31(), 2);
     942             :       Node* effect = graph()->start();
     943             :       Node* control = graph()->start();
     944             : 
     945           9 :       Node* check1 = effect = graph()->NewNode(
     946           9 :           simplified()->CheckBounds(feedback1), lhs, length, effect, control);
     947             :       Reduction r1 = Reduce(check1);
     948           9 :       ASSERT_TRUE(r1.Changed());
     949          18 :       EXPECT_EQ(r1.replacement(), check1);
     950             : 
     951           9 :       Node* check2 = effect = graph()->NewNode(
     952           9 :           simplified()->CheckBounds(feedback2), rhs, length, effect, control);
     953             :       Reduction r2 = Reduce(check2);
     954           9 :       ASSERT_TRUE(r2.Changed());
     955          18 :       EXPECT_EQ(r2.replacement(), check2);
     956             : 
     957             :       Node* cmp3 = effect =
     958           9 :           graph()->NewNode(simplified()->SpeculativeNumberEqual(
     959             :                                NumberOperationHint::kSignedSmall),
     960             :                            lhs, rhs, effect, control);
     961             :       Reduction r3 = Reduce(cmp3);
     962           9 :       ASSERT_TRUE(r3.Changed());
     963          90 :       EXPECT_THAT(r3.replacement(),
     964             :                   IsSpeculativeNumberEqual(NumberOperationHint::kSignedSmall,
     965           0 :                                            check1, check2, _, _));
     966             :     }
     967             :   }
     968             : }
     969             : 
     970       15373 : TEST_F(RedundancyEliminationTest,
     971             :        SpeculativeNumberEqualWithCheckBoundsSameType) {
     972           2 :   Typer typer(broker(), Typer::kNoFlags, graph());
     973          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
     974          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
     975           9 :       Node* lhs = Parameter(Type::UnsignedSmall(), 0);
     976           9 :       Node* rhs = Parameter(Type::UnsignedSmall(), 1);
     977           9 :       Node* length = Parameter(Type::Unsigned31(), 2);
     978             :       Node* effect = graph()->start();
     979             :       Node* control = graph()->start();
     980             : 
     981           9 :       Node* check1 = effect = graph()->NewNode(
     982           9 :           simplified()->CheckBounds(feedback1), lhs, length, effect, control);
     983             :       Reduction r1 = Reduce(check1);
     984           9 :       ASSERT_TRUE(r1.Changed());
     985          18 :       EXPECT_EQ(r1.replacement(), check1);
     986             : 
     987           9 :       Node* check2 = effect = graph()->NewNode(
     988           9 :           simplified()->CheckBounds(feedback2), rhs, length, effect, control);
     989             :       Reduction r2 = Reduce(check2);
     990           9 :       ASSERT_TRUE(r2.Changed());
     991          18 :       EXPECT_EQ(r2.replacement(), check2);
     992             : 
     993             :       Node* cmp3 = effect =
     994           9 :           graph()->NewNode(simplified()->SpeculativeNumberEqual(
     995             :                                NumberOperationHint::kSignedSmall),
     996             :                            lhs, rhs, effect, control);
     997             :       Reduction r3 = Reduce(cmp3);
     998           9 :       ASSERT_TRUE(r3.Changed());
     999          90 :       EXPECT_THAT(r3.replacement(),
    1000             :                   IsSpeculativeNumberEqual(NumberOperationHint::kSignedSmall,
    1001           0 :                                            lhs, rhs, _, _));
    1002             :     }
    1003             :   }
    1004             : }
    1005             : 
    1006             : // -----------------------------------------------------------------------------
    1007             : // SpeculativeNumberLessThan
    1008             : 
    1009       15373 : TEST_F(RedundancyEliminationTest,
    1010             :        SpeculativeNumberLessThanWithCheckBoundsBetterType) {
    1011           2 :   Typer typer(broker(), Typer::kNoFlags, graph());
    1012          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
    1013          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
    1014           9 :       Node* lhs = Parameter(Type::Any(), 0);
    1015           9 :       Node* rhs = Parameter(Type::Any(), 1);
    1016           9 :       Node* length = Parameter(Type::Unsigned31(), 2);
    1017             :       Node* effect = graph()->start();
    1018             :       Node* control = graph()->start();
    1019             : 
    1020           9 :       Node* check1 = effect = graph()->NewNode(
    1021           9 :           simplified()->CheckBounds(feedback1), lhs, length, effect, control);
    1022             :       Reduction r1 = Reduce(check1);
    1023           9 :       ASSERT_TRUE(r1.Changed());
    1024          18 :       EXPECT_EQ(r1.replacement(), check1);
    1025             : 
    1026           9 :       Node* check2 = effect = graph()->NewNode(
    1027           9 :           simplified()->CheckBounds(feedback2), rhs, length, effect, control);
    1028             :       Reduction r2 = Reduce(check2);
    1029           9 :       ASSERT_TRUE(r2.Changed());
    1030          18 :       EXPECT_EQ(r2.replacement(), check2);
    1031             : 
    1032             :       Node* cmp3 = effect =
    1033           9 :           graph()->NewNode(simplified()->SpeculativeNumberLessThan(
    1034             :                                NumberOperationHint::kSignedSmall),
    1035             :                            lhs, rhs, effect, control);
    1036             :       Reduction r3 = Reduce(cmp3);
    1037           9 :       ASSERT_TRUE(r3.Changed());
    1038          90 :       EXPECT_THAT(r3.replacement(),
    1039             :                   IsSpeculativeNumberLessThan(NumberOperationHint::kSignedSmall,
    1040           0 :                                               check1, check2, _, _));
    1041             :     }
    1042             :   }
    1043             : }
    1044             : 
    1045       15373 : TEST_F(RedundancyEliminationTest,
    1046             :        SpeculativeNumberLessThanWithCheckBoundsSameType) {
    1047           2 :   Typer typer(broker(), Typer::kNoFlags, graph());
    1048          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
    1049          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
    1050           9 :       Node* lhs = Parameter(Type::UnsignedSmall(), 0);
    1051           9 :       Node* rhs = Parameter(Type::UnsignedSmall(), 1);
    1052           9 :       Node* length = Parameter(Type::Unsigned31(), 2);
    1053             :       Node* effect = graph()->start();
    1054             :       Node* control = graph()->start();
    1055             : 
    1056           9 :       Node* check1 = effect = graph()->NewNode(
    1057           9 :           simplified()->CheckBounds(feedback1), lhs, length, effect, control);
    1058             :       Reduction r1 = Reduce(check1);
    1059           9 :       ASSERT_TRUE(r1.Changed());
    1060          18 :       EXPECT_EQ(r1.replacement(), check1);
    1061             : 
    1062           9 :       Node* check2 = effect = graph()->NewNode(
    1063           9 :           simplified()->CheckBounds(feedback2), rhs, length, effect, control);
    1064             :       Reduction r2 = Reduce(check2);
    1065           9 :       ASSERT_TRUE(r2.Changed());
    1066          18 :       EXPECT_EQ(r2.replacement(), check2);
    1067             : 
    1068             :       Node* cmp3 = effect =
    1069           9 :           graph()->NewNode(simplified()->SpeculativeNumberLessThan(
    1070             :                                NumberOperationHint::kSignedSmall),
    1071             :                            lhs, rhs, effect, control);
    1072             :       Reduction r3 = Reduce(cmp3);
    1073           9 :       ASSERT_TRUE(r3.Changed());
    1074          90 :       EXPECT_THAT(r3.replacement(),
    1075             :                   IsSpeculativeNumberLessThan(NumberOperationHint::kSignedSmall,
    1076           0 :                                               lhs, rhs, _, _));
    1077             :     }
    1078             :   }
    1079             : }
    1080             : 
    1081             : // -----------------------------------------------------------------------------
    1082             : // SpeculativeNumberLessThanOrEqual
    1083             : 
    1084       15373 : TEST_F(RedundancyEliminationTest,
    1085             :        SpeculativeNumberLessThanOrEqualWithCheckBoundsBetterType) {
    1086           2 :   Typer typer(broker(), Typer::kNoFlags, graph());
    1087          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
    1088          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
    1089           9 :       Node* lhs = Parameter(Type::Any(), 0);
    1090           9 :       Node* rhs = Parameter(Type::Any(), 1);
    1091           9 :       Node* length = Parameter(Type::Unsigned31(), 2);
    1092             :       Node* effect = graph()->start();
    1093             :       Node* control = graph()->start();
    1094             : 
    1095           9 :       Node* check1 = effect = graph()->NewNode(
    1096           9 :           simplified()->CheckBounds(feedback1), lhs, length, effect, control);
    1097             :       Reduction r1 = Reduce(check1);
    1098           9 :       ASSERT_TRUE(r1.Changed());
    1099          18 :       EXPECT_EQ(r1.replacement(), check1);
    1100             : 
    1101           9 :       Node* check2 = effect = graph()->NewNode(
    1102           9 :           simplified()->CheckBounds(feedback2), rhs, length, effect, control);
    1103             :       Reduction r2 = Reduce(check2);
    1104           9 :       ASSERT_TRUE(r2.Changed());
    1105          18 :       EXPECT_EQ(r2.replacement(), check2);
    1106             : 
    1107             :       Node* cmp3 = effect =
    1108           9 :           graph()->NewNode(simplified()->SpeculativeNumberLessThanOrEqual(
    1109             :                                NumberOperationHint::kSignedSmall),
    1110             :                            lhs, rhs, effect, control);
    1111             :       Reduction r3 = Reduce(cmp3);
    1112           9 :       ASSERT_TRUE(r3.Changed());
    1113          90 :       EXPECT_THAT(r3.replacement(),
    1114             :                   IsSpeculativeNumberLessThanOrEqual(
    1115           0 :                       NumberOperationHint::kSignedSmall, check1, check2, _, _));
    1116             :     }
    1117             :   }
    1118             : }
    1119             : 
    1120       15373 : TEST_F(RedundancyEliminationTest,
    1121             :        SpeculativeNumberLessThanOrEqualWithCheckBoundsSameType) {
    1122           2 :   Typer typer(broker(), Typer::kNoFlags, graph());
    1123          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
    1124          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
    1125           9 :       Node* lhs = Parameter(Type::UnsignedSmall(), 0);
    1126           9 :       Node* rhs = Parameter(Type::UnsignedSmall(), 1);
    1127           9 :       Node* length = Parameter(Type::Unsigned31(), 2);
    1128             :       Node* effect = graph()->start();
    1129             :       Node* control = graph()->start();
    1130             : 
    1131           9 :       Node* check1 = effect = graph()->NewNode(
    1132           9 :           simplified()->CheckBounds(feedback1), lhs, length, effect, control);
    1133             :       Reduction r1 = Reduce(check1);
    1134           9 :       ASSERT_TRUE(r1.Changed());
    1135          18 :       EXPECT_EQ(r1.replacement(), check1);
    1136             : 
    1137           9 :       Node* check2 = effect = graph()->NewNode(
    1138           9 :           simplified()->CheckBounds(feedback2), rhs, length, effect, control);
    1139             :       Reduction r2 = Reduce(check2);
    1140           9 :       ASSERT_TRUE(r2.Changed());
    1141          18 :       EXPECT_EQ(r2.replacement(), check2);
    1142             : 
    1143             :       Node* cmp3 = effect =
    1144           9 :           graph()->NewNode(simplified()->SpeculativeNumberLessThanOrEqual(
    1145             :                                NumberOperationHint::kSignedSmall),
    1146             :                            lhs, rhs, effect, control);
    1147             :       Reduction r3 = Reduce(cmp3);
    1148           9 :       ASSERT_TRUE(r3.Changed());
    1149          90 :       EXPECT_THAT(r3.replacement(),
    1150             :                   IsSpeculativeNumberLessThanOrEqual(
    1151           0 :                       NumberOperationHint::kSignedSmall, lhs, rhs, _, _));
    1152             :     }
    1153             :   }
    1154             : }
    1155             : 
    1156             : // -----------------------------------------------------------------------------
    1157             : // SpeculativeNumberAdd
    1158             : 
    1159       15373 : TEST_F(RedundancyEliminationTest,
    1160             :        SpeculativeNumberAddWithCheckBoundsBetterType) {
    1161           2 :   Typer typer(broker(), Typer::kNoFlags, graph());
    1162          13 :   TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
    1163          63 :     TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
    1164          15 :       Node* lhs = Parameter(Type::Any(), 0);
    1165          15 :       Node* rhs = Parameter(Type::Any(), 1);
    1166          15 :       Node* length = Parameter(Type::Unsigned31(), 2);
    1167             :       Node* effect = graph()->start();
    1168             :       Node* control = graph()->start();
    1169             : 
    1170          15 :       Node* check1 = effect = graph()->NewNode(
    1171          15 :           simplified()->CheckBounds(feedback), lhs, length, effect, control);
    1172             :       Reduction r1 = Reduce(check1);
    1173          15 :       ASSERT_TRUE(r1.Changed());
    1174          30 :       EXPECT_EQ(r1.replacement(), check1);
    1175             : 
    1176          15 :       Node* add2 = effect = graph()->NewNode(
    1177             :           simplified()->SpeculativeNumberAdd(hint), lhs, rhs, effect, control);
    1178             :       Reduction r2 = Reduce(add2);
    1179          15 :       ASSERT_TRUE(r2.Changed());
    1180         150 :       EXPECT_THAT(r2.replacement(),
    1181           0 :                   IsSpeculativeNumberAdd(hint, check1, rhs, _, _));
    1182             :     }
    1183             :   }
    1184             : }
    1185             : 
    1186       15373 : TEST_F(RedundancyEliminationTest, SpeculativeNumberAddWithCheckBoundsSameType) {
    1187           2 :   Typer typer(broker(), Typer::kNoFlags, graph());
    1188          13 :   TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
    1189          63 :     TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
    1190          15 :       Node* lhs = Parameter(Type::Range(42.0, 42.0, zone()), 0);
    1191          15 :       Node* rhs = Parameter(Type::Any(), 0);
    1192          15 :       Node* length = Parameter(Type::Unsigned31(), 1);
    1193             :       Node* effect = graph()->start();
    1194             :       Node* control = graph()->start();
    1195             : 
    1196          15 :       Node* check1 = effect = graph()->NewNode(
    1197          15 :           simplified()->CheckBounds(feedback), lhs, length, effect, control);
    1198             :       Reduction r1 = Reduce(check1);
    1199          15 :       ASSERT_TRUE(r1.Changed());
    1200          30 :       EXPECT_EQ(r1.replacement(), check1);
    1201             : 
    1202          15 :       Node* add2 = effect = graph()->NewNode(
    1203             :           simplified()->SpeculativeNumberAdd(hint), lhs, rhs, effect, control);
    1204             :       Reduction r2 = Reduce(add2);
    1205          15 :       ASSERT_TRUE(r2.Changed());
    1206         150 :       EXPECT_THAT(r2.replacement(),
    1207           0 :                   IsSpeculativeNumberAdd(hint, lhs, rhs, _, _));
    1208             :     }
    1209             :   }
    1210             : }
    1211             : 
    1212             : // -----------------------------------------------------------------------------
    1213             : // SpeculativeNumberSubtract
    1214             : 
    1215       15373 : TEST_F(RedundancyEliminationTest,
    1216             :        SpeculativeNumberSubtractWithCheckBoundsBetterType) {
    1217           2 :   Typer typer(broker(), Typer::kNoFlags, graph());
    1218          13 :   TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
    1219          63 :     TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
    1220          15 :       Node* lhs = Parameter(Type::Any(), 0);
    1221          15 :       Node* rhs = Parameter(Type::Any(), 1);
    1222          15 :       Node* length = Parameter(Type::Unsigned31(), 2);
    1223             :       Node* effect = graph()->start();
    1224             :       Node* control = graph()->start();
    1225             : 
    1226          15 :       Node* check1 = effect = graph()->NewNode(
    1227          15 :           simplified()->CheckBounds(feedback), lhs, length, effect, control);
    1228             :       Reduction r1 = Reduce(check1);
    1229          15 :       ASSERT_TRUE(r1.Changed());
    1230          30 :       EXPECT_EQ(r1.replacement(), check1);
    1231             : 
    1232             :       Node* subtract2 = effect =
    1233          15 :           graph()->NewNode(simplified()->SpeculativeNumberSubtract(hint), lhs,
    1234             :                            rhs, effect, control);
    1235             :       Reduction r2 = Reduce(subtract2);
    1236          15 :       ASSERT_TRUE(r2.Changed());
    1237         150 :       EXPECT_THAT(r2.replacement(),
    1238           0 :                   IsSpeculativeNumberSubtract(hint, check1, rhs, _, _));
    1239             :     }
    1240             :   }
    1241             : }
    1242             : 
    1243       15373 : TEST_F(RedundancyEliminationTest,
    1244             :        SpeculativeNumberSubtractWithCheckBoundsSameType) {
    1245           2 :   Typer typer(broker(), Typer::kNoFlags, graph());
    1246          13 :   TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
    1247          63 :     TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
    1248          15 :       Node* lhs = Parameter(Type::Range(42.0, 42.0, zone()), 0);
    1249          15 :       Node* rhs = Parameter(Type::Any(), 0);
    1250          15 :       Node* length = Parameter(Type::Unsigned31(), 1);
    1251             :       Node* effect = graph()->start();
    1252             :       Node* control = graph()->start();
    1253             : 
    1254          15 :       Node* check1 = effect = graph()->NewNode(
    1255          15 :           simplified()->CheckBounds(feedback), lhs, length, effect, control);
    1256             :       Reduction r1 = Reduce(check1);
    1257          15 :       ASSERT_TRUE(r1.Changed());
    1258          30 :       EXPECT_EQ(r1.replacement(), check1);
    1259             : 
    1260             :       Node* subtract2 = effect =
    1261          15 :           graph()->NewNode(simplified()->SpeculativeNumberSubtract(hint), lhs,
    1262             :                            rhs, effect, control);
    1263             :       Reduction r2 = Reduce(subtract2);
    1264          15 :       ASSERT_TRUE(r2.Changed());
    1265         150 :       EXPECT_THAT(r2.replacement(),
    1266           0 :                   IsSpeculativeNumberSubtract(hint, lhs, rhs, _, _));
    1267             :     }
    1268             :   }
    1269             : }
    1270             : 
    1271             : // -----------------------------------------------------------------------------
    1272             : // SpeculativeSafeIntegerAdd
    1273             : 
    1274       15373 : TEST_F(RedundancyEliminationTest,
    1275             :        SpeculativeSafeIntegerAddWithCheckBoundsBetterType) {
    1276           2 :   Typer typer(broker(), Typer::kNoFlags, graph());
    1277          13 :   TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
    1278          63 :     TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
    1279          15 :       Node* lhs = Parameter(Type::Any(), 0);
    1280          15 :       Node* rhs = Parameter(Type::Any(), 1);
    1281          15 :       Node* length = Parameter(Type::Unsigned31(), 2);
    1282             :       Node* effect = graph()->start();
    1283             :       Node* control = graph()->start();
    1284             : 
    1285          15 :       Node* check1 = effect = graph()->NewNode(
    1286          15 :           simplified()->CheckBounds(feedback), lhs, length, effect, control);
    1287             :       Reduction r1 = Reduce(check1);
    1288          15 :       ASSERT_TRUE(r1.Changed());
    1289          30 :       EXPECT_EQ(r1.replacement(), check1);
    1290             : 
    1291             :       Node* add2 = effect =
    1292          15 :           graph()->NewNode(simplified()->SpeculativeSafeIntegerAdd(hint), lhs,
    1293             :                            rhs, effect, control);
    1294             :       Reduction r2 = Reduce(add2);
    1295          15 :       ASSERT_TRUE(r2.Changed());
    1296         150 :       EXPECT_THAT(r2.replacement(),
    1297           0 :                   IsSpeculativeSafeIntegerAdd(hint, check1, rhs, _, _));
    1298             :     }
    1299             :   }
    1300             : }
    1301             : 
    1302       15373 : TEST_F(RedundancyEliminationTest,
    1303             :        SpeculativeSafeIntegerAddWithCheckBoundsSameType) {
    1304           2 :   Typer typer(broker(), Typer::kNoFlags, graph());
    1305          13 :   TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
    1306          63 :     TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
    1307          15 :       Node* lhs = Parameter(Type::Range(42.0, 42.0, zone()), 0);
    1308          15 :       Node* rhs = Parameter(Type::Any(), 0);
    1309          15 :       Node* length = Parameter(Type::Unsigned31(), 1);
    1310             :       Node* effect = graph()->start();
    1311             :       Node* control = graph()->start();
    1312             : 
    1313          15 :       Node* check1 = effect = graph()->NewNode(
    1314          15 :           simplified()->CheckBounds(feedback), lhs, length, effect, control);
    1315             :       Reduction r1 = Reduce(check1);
    1316          15 :       ASSERT_TRUE(r1.Changed());
    1317          30 :       EXPECT_EQ(r1.replacement(), check1);
    1318             : 
    1319             :       Node* add2 = effect =
    1320          15 :           graph()->NewNode(simplified()->SpeculativeSafeIntegerAdd(hint), lhs,
    1321             :                            rhs, effect, control);
    1322             :       Reduction r2 = Reduce(add2);
    1323          15 :       ASSERT_TRUE(r2.Changed());
    1324         150 :       EXPECT_THAT(r2.replacement(),
    1325           0 :                   IsSpeculativeSafeIntegerAdd(hint, lhs, rhs, _, _));
    1326             :     }
    1327             :   }
    1328             : }
    1329             : 
    1330             : // -----------------------------------------------------------------------------
    1331             : // SpeculativeSafeIntegerSubtract
    1332             : 
    1333       15373 : TEST_F(RedundancyEliminationTest,
    1334             :        SpeculativeSafeIntegerSubtractWithCheckBoundsBetterType) {
    1335           2 :   Typer typer(broker(), Typer::kNoFlags, graph());
    1336          13 :   TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
    1337          63 :     TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
    1338          15 :       Node* lhs = Parameter(Type::Any(), 0);
    1339          15 :       Node* rhs = Parameter(Type::Any(), 1);
    1340          15 :       Node* length = Parameter(Type::Unsigned31(), 2);
    1341             :       Node* effect = graph()->start();
    1342             :       Node* control = graph()->start();
    1343             : 
    1344          15 :       Node* check1 = effect = graph()->NewNode(
    1345          15 :           simplified()->CheckBounds(feedback), lhs, length, effect, control);
    1346             :       Reduction r1 = Reduce(check1);
    1347          15 :       ASSERT_TRUE(r1.Changed());
    1348          30 :       EXPECT_EQ(r1.replacement(), check1);
    1349             : 
    1350             :       Node* subtract2 = effect =
    1351          15 :           graph()->NewNode(simplified()->SpeculativeSafeIntegerSubtract(hint),
    1352             :                            lhs, rhs, effect, control);
    1353             :       Reduction r2 = Reduce(subtract2);
    1354          15 :       ASSERT_TRUE(r2.Changed());
    1355         150 :       EXPECT_THAT(r2.replacement(),
    1356           0 :                   IsSpeculativeSafeIntegerSubtract(hint, check1, rhs, _, _));
    1357             :     }
    1358             :   }
    1359             : }
    1360             : 
    1361       15373 : TEST_F(RedundancyEliminationTest,
    1362             :        SpeculativeSafeIntegerSubtractWithCheckBoundsSameType) {
    1363           2 :   Typer typer(broker(), Typer::kNoFlags, graph());
    1364          13 :   TRACED_FOREACH(VectorSlotPair, feedback, vector_slot_pairs()) {
    1365          63 :     TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
    1366          15 :       Node* lhs = Parameter(Type::Range(42.0, 42.0, zone()), 0);
    1367          15 :       Node* rhs = Parameter(Type::Any(), 0);
    1368          15 :       Node* length = Parameter(Type::Unsigned31(), 1);
    1369             :       Node* effect = graph()->start();
    1370             :       Node* control = graph()->start();
    1371             : 
    1372          15 :       Node* check1 = effect = graph()->NewNode(
    1373          15 :           simplified()->CheckBounds(feedback), lhs, length, effect, control);
    1374             :       Reduction r1 = Reduce(check1);
    1375          15 :       ASSERT_TRUE(r1.Changed());
    1376          30 :       EXPECT_EQ(r1.replacement(), check1);
    1377             : 
    1378             :       Node* subtract2 = effect =
    1379          15 :           graph()->NewNode(simplified()->SpeculativeSafeIntegerSubtract(hint),
    1380             :                            lhs, rhs, effect, control);
    1381             :       Reduction r2 = Reduce(subtract2);
    1382          15 :       ASSERT_TRUE(r2.Changed());
    1383         150 :       EXPECT_THAT(r2.replacement(),
    1384           0 :                   IsSpeculativeSafeIntegerSubtract(hint, lhs, rhs, _, _));
    1385             :     }
    1386             :   }
    1387             : }
    1388             : 
    1389             : // -----------------------------------------------------------------------------
    1390             : // SpeculativeToNumber
    1391             : 
    1392       15373 : TEST_F(RedundancyEliminationTest,
    1393             :        SpeculativeToNumberWithCheckBoundsBetterType) {
    1394           2 :   Typer typer(broker(), Typer::kNoFlags, graph());
    1395          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
    1396          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
    1397         189 :       TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
    1398          45 :         Node* index = Parameter(Type::Any(), 0);
    1399          45 :         Node* length = Parameter(Type::Unsigned31(), 1);
    1400             :         Node* effect = graph()->start();
    1401             :         Node* control = graph()->start();
    1402             : 
    1403             :         Node* check1 = effect =
    1404          45 :             graph()->NewNode(simplified()->CheckBounds(feedback1), index,
    1405          45 :                              length, effect, control);
    1406             :         Reduction r1 = Reduce(check1);
    1407          45 :         ASSERT_TRUE(r1.Changed());
    1408          90 :         EXPECT_EQ(r1.replacement(), check1);
    1409             : 
    1410             :         Node* to_number2 = effect =
    1411          45 :             graph()->NewNode(simplified()->SpeculativeToNumber(hint, feedback2),
    1412             :                              index, effect, control);
    1413             :         Reduction r2 = Reduce(to_number2);
    1414          45 :         ASSERT_TRUE(r2.Changed());
    1415         225 :         EXPECT_THAT(r2.replacement(), IsSpeculativeToNumber(check1));
    1416             :       }
    1417             :     }
    1418             :   }
    1419             : }
    1420             : 
    1421       15373 : TEST_F(RedundancyEliminationTest, SpeculativeToNumberWithCheckBoundsSameType) {
    1422           2 :   Typer typer(broker(), Typer::kNoFlags, graph());
    1423          13 :   TRACED_FOREACH(VectorSlotPair, feedback1, vector_slot_pairs()) {
    1424          39 :     TRACED_FOREACH(VectorSlotPair, feedback2, vector_slot_pairs()) {
    1425         189 :       TRACED_FOREACH(NumberOperationHint, hint, kNumberOperationHints) {
    1426          45 :         Node* index = Parameter(Type::Range(42.0, 42.0, zone()), 0);
    1427          45 :         Node* length = Parameter(Type::Unsigned31(), 1);
    1428             :         Node* effect = graph()->start();
    1429             :         Node* control = graph()->start();
    1430             : 
    1431             :         Node* check1 = effect =
    1432          45 :             graph()->NewNode(simplified()->CheckBounds(feedback1), index,
    1433          45 :                              length, effect, control);
    1434             :         Reduction r1 = Reduce(check1);
    1435          45 :         ASSERT_TRUE(r1.Changed());
    1436          90 :         EXPECT_EQ(r1.replacement(), check1);
    1437             : 
    1438             :         Node* to_number2 = effect =
    1439          45 :             graph()->NewNode(simplified()->SpeculativeToNumber(hint, feedback2),
    1440             :                              index, effect, control);
    1441             :         Reduction r2 = Reduce(to_number2);
    1442          45 :         ASSERT_TRUE(r2.Changed());
    1443         225 :         EXPECT_THAT(r2.replacement(), IsSpeculativeToNumber(index));
    1444             :       }
    1445             :     }
    1446             :   }
    1447             : }
    1448             : 
    1449             : }  // namespace redundancy_elimination_unittest
    1450             : }  // namespace compiler
    1451             : }  // namespace internal
    1452        9222 : }  // namespace v8

Generated by: LCOV version 1.10