LCOV - code coverage report
Current view: top level - test/unittests/compiler - simplified-operator-reducer-unittest.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 189 189 100.0 %
Date: 2019-03-21 Functions: 105 139 75.5 %

          Line data    Source code
       1             : // Copyright 2014 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/simplified-operator.h"
       6             : #include "src/compiler/access-builder.h"
       7             : #include "src/compiler/js-graph.h"
       8             : #include "src/compiler/node-properties.h"
       9             : #include "src/compiler/simplified-operator-reducer.h"
      10             : #include "src/compiler/types.h"
      11             : #include "src/conversions-inl.h"
      12             : #include "test/unittests/compiler/graph-unittest.h"
      13             : #include "test/unittests/compiler/node-test-utils.h"
      14             : #include "testing/gmock-support.h"
      15             : 
      16             : using testing::BitEq;
      17             : 
      18             : 
      19             : namespace v8 {
      20             : namespace internal {
      21             : namespace compiler {
      22             : namespace simplified_operator_reducer_unittest {
      23             : 
      24             : class SimplifiedOperatorReducerTest : public GraphTest {
      25             :  public:
      26             :   explicit SimplifiedOperatorReducerTest(int num_parameters = 1)
      27          68 :       : GraphTest(num_parameters), simplified_(zone()) {}
      28          34 :   ~SimplifiedOperatorReducerTest() override = default;
      29             : 
      30             :  protected:
      31         840 :   Reduction Reduce(Node* node) {
      32        1680 :     JSHeapBroker broker(isolate(), zone());
      33         840 :     MachineOperatorBuilder machine(zone());
      34         840 :     JSOperatorBuilder javascript(zone());
      35             :     JSGraph jsgraph(isolate(), graph(), common(), &javascript, simplified(),
      36         840 :                     &machine);
      37        1680 :     GraphReducer graph_reducer(zone(), graph());
      38        1680 :     SimplifiedOperatorReducer reducer(&graph_reducer, &jsgraph, &broker);
      39        1680 :     return reducer.Reduce(node);
      40             :   }
      41             : 
      42        1680 :   SimplifiedOperatorBuilder* simplified() { return &simplified_; }
      43             : 
      44             :  private:
      45             :   SimplifiedOperatorBuilder simplified_;
      46             : };
      47             : 
      48             : 
      49             : template <typename T>
      50             : class SimplifiedOperatorReducerTestWithParam
      51             :     : public SimplifiedOperatorReducerTest,
      52             :       public ::testing::WithParamInterface<T> {
      53             :  public:
      54             :   explicit SimplifiedOperatorReducerTestWithParam(int num_parameters = 1)
      55             :       : SimplifiedOperatorReducerTest(num_parameters) {}
      56             :   ~SimplifiedOperatorReducerTestWithParam() override = default;
      57             : };
      58             : 
      59             : 
      60             : namespace {
      61             : 
      62             : const double kFloat64Values[] = {
      63             :     -V8_INFINITY, -6.52696e+290, -1.05768e+290, -5.34203e+268, -1.01997e+268,
      64             :     -8.22758e+266, -1.58402e+261, -5.15246e+241, -5.92107e+226, -1.21477e+226,
      65             :     -1.67913e+188, -1.6257e+184, -2.60043e+170, -2.52941e+168, -3.06033e+116,
      66             :     -4.56201e+52, -3.56788e+50, -9.9066e+38, -3.07261e+31, -2.1271e+09,
      67             :     -1.91489e+09, -1.73053e+09, -9.30675e+08, -26030, -20453, -15790, -11699,
      68             :     -111, -97, -78, -63, -58, -1.53858e-06, -2.98914e-12, -1.14741e-39,
      69             :     -8.20347e-57, -1.48932e-59, -3.17692e-66, -8.93103e-81, -3.91337e-83,
      70             :     -6.0489e-92, -8.83291e-113, -4.28266e-117, -1.92058e-178, -2.0567e-192,
      71             :     -1.68167e-194, -1.51841e-214, -3.98738e-234, -7.31851e-242, -2.21875e-253,
      72             :     -1.11612e-293, -0.0, 0.0, 2.22507e-308, 1.06526e-307, 4.16643e-227,
      73             :     6.76624e-223, 2.0432e-197, 3.16254e-184, 1.37315e-173, 2.88603e-172,
      74             :     1.54155e-99, 4.42923e-81, 1.40539e-73, 5.4462e-73, 1.24064e-58, 3.11167e-58,
      75             :     2.75826e-39, 0.143815, 58, 67, 601, 7941, 11644, 13697, 25680, 29882,
      76             :     1.32165e+08, 1.62439e+08, 4.16837e+08, 9.59097e+08, 1.32491e+09, 1.8728e+09,
      77             :     1.0672e+17, 2.69606e+46, 1.98285e+79, 1.0098e+82, 7.93064e+88, 3.67444e+121,
      78             :     9.36506e+123, 7.27954e+162, 3.05316e+168, 1.16171e+175, 1.64771e+189,
      79             :     1.1622e+202, 2.00748e+239, 2.51778e+244, 3.90282e+306, 1.79769e+308,
      80             :     V8_INFINITY};
      81             : 
      82             : 
      83             : const int32_t kInt32Values[] = {
      84             :     -2147483647 - 1, -2104508227, -2103151830, -1435284490, -1378926425,
      85             :     -1318814539, -1289388009, -1287537572, -1279026536, -1241605942,
      86             :     -1226046939, -941837148, -779818051, -413830641, -245798087, -184657557,
      87             :     -127145950, -105483328, -32325, -26653, -23858, -23834, -22363, -19858,
      88             :     -19044, -18744, -15528, -5309, -3372, -2093, -104, -98, -97, -93, -84, -80,
      89             :     -78, -76, -72, -58, -57, -56, -55, -45, -40, -34, -32, -25, -24, -5, -2, 0,
      90             :     3, 10, 24, 34, 42, 46, 47, 48, 52, 56, 64, 65, 71, 76, 79, 81, 82, 97, 102,
      91             :     103, 104, 106, 107, 109, 116, 122, 3653, 4485, 12405, 16504, 26262, 28704,
      92             :     29755, 30554, 16476817, 605431957, 832401070, 873617242, 914205764,
      93             :     1062628108, 1087581664, 1488498068, 1534668023, 1661587028, 1696896187,
      94             :     1866841746, 2032089723, 2147483647};
      95             : 
      96             : const double kNaNs[] = {-std::numeric_limits<double>::quiet_NaN(),
      97             :                         std::numeric_limits<double>::quiet_NaN(),
      98             :                         bit_cast<double>(uint64_t{0x7FFFFFFFFFFFFFFF}),
      99        3074 :                         bit_cast<double>(uint64_t{0xFFFFFFFFFFFFFFFF})};
     100             : 
     101             : const CheckForMinusZeroMode kCheckForMinusZeroModes[] = {
     102             :     CheckForMinusZeroMode::kDontCheckForMinusZero,
     103             :     CheckForMinusZeroMode::kCheckForMinusZero};
     104             : 
     105             : }  // namespace
     106             : 
     107             : 
     108             : // -----------------------------------------------------------------------------
     109             : // BooleanNot
     110             : 
     111             : 
     112       15375 : TEST_F(SimplifiedOperatorReducerTest, BooleanNotWithBooleanNot) {
     113           1 :   Node* param0 = Parameter(0);
     114             :   Reduction reduction = Reduce(
     115             :       graph()->NewNode(simplified()->BooleanNot(),
     116           3 :                        graph()->NewNode(simplified()->BooleanNot(), param0)));
     117           1 :   ASSERT_TRUE(reduction.Changed());
     118           2 :   EXPECT_EQ(param0, reduction.replacement());
     119             : }
     120             : 
     121             : 
     122       15375 : TEST_F(SimplifiedOperatorReducerTest, BooleanNotWithFalseConstant) {
     123             :   Reduction reduction0 =
     124           3 :       Reduce(graph()->NewNode(simplified()->BooleanNot(), FalseConstant()));
     125           1 :   ASSERT_TRUE(reduction0.Changed());
     126           4 :   EXPECT_THAT(reduction0.replacement(), IsTrueConstant());
     127             : }
     128             : 
     129             : 
     130       15375 : TEST_F(SimplifiedOperatorReducerTest, BooleanNotWithTrueConstant) {
     131             :   Reduction reduction1 =
     132           3 :       Reduce(graph()->NewNode(simplified()->BooleanNot(), TrueConstant()));
     133           1 :   ASSERT_TRUE(reduction1.Changed());
     134           4 :   EXPECT_THAT(reduction1.replacement(), IsFalseConstant());
     135             : }
     136             : 
     137             : 
     138             : // -----------------------------------------------------------------------------
     139             : // ChangeTaggedToBit
     140             : 
     141       15375 : TEST_F(SimplifiedOperatorReducerTest, ChangeBitToTaggedWithChangeTaggedToBit) {
     142           1 :   Node* param0 = Parameter(0);
     143             :   Reduction reduction = Reduce(graph()->NewNode(
     144             :       simplified()->ChangeBitToTagged(),
     145           3 :       graph()->NewNode(simplified()->ChangeTaggedToBit(), param0)));
     146           1 :   ASSERT_TRUE(reduction.Changed());
     147           2 :   EXPECT_EQ(param0, reduction.replacement());
     148             : }
     149             : 
     150       15375 : TEST_F(SimplifiedOperatorReducerTest, ChangeBitToTaggedWithZeroConstant) {
     151             :   Reduction reduction = Reduce(
     152           3 :       graph()->NewNode(simplified()->ChangeBitToTagged(), Int32Constant(0)));
     153           1 :   ASSERT_TRUE(reduction.Changed());
     154           4 :   EXPECT_THAT(reduction.replacement(), IsFalseConstant());
     155             : }
     156             : 
     157       15375 : TEST_F(SimplifiedOperatorReducerTest, ChangeBitToTaggedWithOneConstant) {
     158             :   Reduction reduction = Reduce(
     159           3 :       graph()->NewNode(simplified()->ChangeBitToTagged(), Int32Constant(1)));
     160           1 :   ASSERT_TRUE(reduction.Changed());
     161           4 :   EXPECT_THAT(reduction.replacement(), IsTrueConstant());
     162             : }
     163             : 
     164             : 
     165             : // -----------------------------------------------------------------------------
     166             : // ChangeTaggedToBit
     167             : 
     168       15375 : TEST_F(SimplifiedOperatorReducerTest, ChangeTaggedToBitWithFalseConstant) {
     169             :   Reduction reduction = Reduce(
     170           3 :       graph()->NewNode(simplified()->ChangeTaggedToBit(), FalseConstant()));
     171           1 :   ASSERT_TRUE(reduction.Changed());
     172           5 :   EXPECT_THAT(reduction.replacement(), IsInt32Constant(0));
     173             : }
     174             : 
     175       15375 : TEST_F(SimplifiedOperatorReducerTest, ChangeTaggedToBitWithTrueConstant) {
     176             :   Reduction reduction = Reduce(
     177           3 :       graph()->NewNode(simplified()->ChangeTaggedToBit(), TrueConstant()));
     178           1 :   ASSERT_TRUE(reduction.Changed());
     179           5 :   EXPECT_THAT(reduction.replacement(), IsInt32Constant(1));
     180             : }
     181             : 
     182       15375 : TEST_F(SimplifiedOperatorReducerTest, ChangeTaggedToBitWithChangeBitToTagged) {
     183           1 :   Node* param0 = Parameter(0);
     184             :   Reduction reduction = Reduce(graph()->NewNode(
     185             :       simplified()->ChangeTaggedToBit(),
     186           3 :       graph()->NewNode(simplified()->ChangeBitToTagged(), param0)));
     187           1 :   ASSERT_TRUE(reduction.Changed());
     188           2 :   EXPECT_EQ(param0, reduction.replacement());
     189             : }
     190             : 
     191             : // -----------------------------------------------------------------------------
     192             : // ChangeFloat64ToTagged
     193             : 
     194       15375 : TEST_F(SimplifiedOperatorReducerTest, ChangeFloat64ToTaggedWithConstant) {
     195           9 :   TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) {
     196         802 :     TRACED_FOREACH(double, n, kFloat64Values) {
     197             :       Reduction reduction = Reduce(graph()->NewNode(
     198         600 :           simplified()->ChangeFloat64ToTagged(mode), Float64Constant(n)));
     199         200 :       ASSERT_TRUE(reduction.Changed());
     200        1000 :       EXPECT_THAT(reduction.replacement(), IsNumberConstant(BitEq(n)));
     201             :     }
     202             :   }
     203             : }
     204             : 
     205             : // -----------------------------------------------------------------------------
     206             : // ChangeInt32ToTagged
     207             : 
     208             : 
     209       15375 : TEST_F(SimplifiedOperatorReducerTest, ChangeInt32ToTaggedWithConstant) {
     210         401 :   TRACED_FOREACH(int32_t, n, kInt32Values) {
     211             :     Reduction reduction = Reduce(graph()->NewNode(
     212         300 :         simplified()->ChangeInt32ToTagged(), Int32Constant(n)));
     213         100 :     ASSERT_TRUE(reduction.Changed());
     214         600 :     EXPECT_THAT(reduction.replacement(), IsNumberConstant(BitEq(FastI2D(n))));
     215             :   }
     216             : }
     217             : 
     218             : 
     219             : // -----------------------------------------------------------------------------
     220             : // ChangeTaggedToFloat64
     221             : 
     222             : 
     223       15375 : TEST_F(SimplifiedOperatorReducerTest,
     224             :        ChangeTaggedToFloat64WithChangeFloat64ToTagged) {
     225           1 :   Node* param0 = Parameter(0);
     226           9 :   TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) {
     227             :     Reduction reduction = Reduce(graph()->NewNode(
     228             :         simplified()->ChangeTaggedToFloat64(),
     229           8 :         graph()->NewNode(simplified()->ChangeFloat64ToTagged(mode), param0)));
     230           2 :     ASSERT_TRUE(reduction.Changed());
     231           4 :     EXPECT_EQ(param0, reduction.replacement());
     232             :   }
     233             : }
     234             : 
     235       15375 : TEST_F(SimplifiedOperatorReducerTest,
     236             :        ChangeTaggedToFloat64WithChangeInt32ToTagged) {
     237           1 :   Node* param0 = Parameter(0);
     238             :   Reduction reduction = Reduce(graph()->NewNode(
     239             :       simplified()->ChangeTaggedToFloat64(),
     240           3 :       graph()->NewNode(simplified()->ChangeInt32ToTagged(), param0)));
     241           1 :   ASSERT_TRUE(reduction.Changed());
     242           5 :   EXPECT_THAT(reduction.replacement(), IsChangeInt32ToFloat64(param0));
     243             : }
     244             : 
     245             : 
     246       15375 : TEST_F(SimplifiedOperatorReducerTest,
     247             :        ChangeTaggedToFloat64WithChangeUint32ToTagged) {
     248           1 :   Node* param0 = Parameter(0);
     249             :   Reduction reduction = Reduce(graph()->NewNode(
     250             :       simplified()->ChangeTaggedToFloat64(),
     251           3 :       graph()->NewNode(simplified()->ChangeUint32ToTagged(), param0)));
     252           1 :   ASSERT_TRUE(reduction.Changed());
     253           5 :   EXPECT_THAT(reduction.replacement(), IsChangeUint32ToFloat64(param0));
     254             : }
     255             : 
     256             : 
     257       15375 : TEST_F(SimplifiedOperatorReducerTest, ChangeTaggedToFloat64WithConstant) {
     258         401 :   TRACED_FOREACH(double, n, kFloat64Values) {
     259             :     Reduction reduction = Reduce(graph()->NewNode(
     260         300 :         simplified()->ChangeTaggedToFloat64(), NumberConstant(n)));
     261         100 :     ASSERT_TRUE(reduction.Changed());
     262         500 :     EXPECT_THAT(reduction.replacement(), IsFloat64Constant(BitEq(n)));
     263             :   }
     264             : }
     265             : 
     266             : 
     267       15375 : TEST_F(SimplifiedOperatorReducerTest, ChangeTaggedToFloat64WithNaNConstant) {
     268          17 :   TRACED_FOREACH(double, nan, kNaNs) {
     269             :     Reduction reduction = Reduce(graph()->NewNode(
     270          12 :         simplified()->ChangeTaggedToFloat64(), NumberConstant(nan)));
     271           4 :     ASSERT_TRUE(reduction.Changed());
     272          20 :     EXPECT_THAT(reduction.replacement(), IsFloat64Constant(BitEq(nan)));
     273             :   }
     274             : }
     275             : 
     276             : 
     277             : // -----------------------------------------------------------------------------
     278             : // ChangeTaggedToInt32
     279             : 
     280       15375 : TEST_F(SimplifiedOperatorReducerTest,
     281             :        ChangeTaggedToInt32WithChangeFloat64ToTagged) {
     282           1 :   Node* param0 = Parameter(0);
     283           9 :   TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) {
     284             :     Reduction reduction = Reduce(graph()->NewNode(
     285             :         simplified()->ChangeTaggedToInt32(),
     286           6 :         graph()->NewNode(simplified()->ChangeFloat64ToTagged(mode), param0)));
     287           2 :     ASSERT_TRUE(reduction.Changed());
     288          10 :     EXPECT_THAT(reduction.replacement(), IsChangeFloat64ToInt32(param0));
     289             :   }
     290             : }
     291             : 
     292       15375 : TEST_F(SimplifiedOperatorReducerTest,
     293             :        ChangeTaggedToInt32WithChangeInt32ToTagged) {
     294           1 :   Node* param0 = Parameter(0);
     295             :   Reduction reduction = Reduce(graph()->NewNode(
     296             :       simplified()->ChangeTaggedToInt32(),
     297           3 :       graph()->NewNode(simplified()->ChangeInt32ToTagged(), param0)));
     298           1 :   ASSERT_TRUE(reduction.Changed());
     299           2 :   EXPECT_EQ(param0, reduction.replacement());
     300             : }
     301             : 
     302             : 
     303             : // -----------------------------------------------------------------------------
     304             : // ChangeTaggedToUint32
     305             : 
     306       15375 : TEST_F(SimplifiedOperatorReducerTest,
     307             :        ChangeTaggedToUint32WithChangeFloat64ToTagged) {
     308           1 :   Node* param0 = Parameter(0);
     309           9 :   TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) {
     310             :     Reduction reduction = Reduce(graph()->NewNode(
     311             :         simplified()->ChangeTaggedToUint32(),
     312           6 :         graph()->NewNode(simplified()->ChangeFloat64ToTagged(mode), param0)));
     313           2 :     ASSERT_TRUE(reduction.Changed());
     314          10 :     EXPECT_THAT(reduction.replacement(), IsChangeFloat64ToUint32(param0));
     315             :   }
     316             : }
     317             : 
     318       15375 : TEST_F(SimplifiedOperatorReducerTest,
     319             :        ChangeTaggedToUint32WithChangeUint32ToTagged) {
     320           1 :   Node* param0 = Parameter(0);
     321             :   Reduction reduction = Reduce(graph()->NewNode(
     322             :       simplified()->ChangeTaggedToUint32(),
     323           3 :       graph()->NewNode(simplified()->ChangeUint32ToTagged(), param0)));
     324           1 :   ASSERT_TRUE(reduction.Changed());
     325           2 :   EXPECT_EQ(param0, reduction.replacement());
     326             : }
     327             : 
     328             : 
     329             : // -----------------------------------------------------------------------------
     330             : // TruncateTaggedToWord32
     331             : 
     332       15375 : TEST_F(SimplifiedOperatorReducerTest,
     333             :        TruncateTaggedToWord3WithChangeFloat64ToTagged) {
     334           1 :   Node* param0 = Parameter(0);
     335           9 :   TRACED_FOREACH(CheckForMinusZeroMode, mode, kCheckForMinusZeroModes) {
     336             :     Reduction reduction = Reduce(graph()->NewNode(
     337             :         simplified()->TruncateTaggedToWord32(),
     338           6 :         graph()->NewNode(simplified()->ChangeFloat64ToTagged(mode), param0)));
     339           2 :     ASSERT_TRUE(reduction.Changed());
     340          10 :     EXPECT_THAT(reduction.replacement(), IsTruncateFloat64ToWord32(param0));
     341             :   }
     342             : }
     343             : 
     344       15375 : TEST_F(SimplifiedOperatorReducerTest, TruncateTaggedToWord32WithConstant) {
     345         401 :   TRACED_FOREACH(double, n, kFloat64Values) {
     346             :     Reduction reduction = Reduce(graph()->NewNode(
     347         300 :         simplified()->TruncateTaggedToWord32(), NumberConstant(n)));
     348         100 :     ASSERT_TRUE(reduction.Changed());
     349         500 :     EXPECT_THAT(reduction.replacement(), IsInt32Constant(DoubleToInt32(n)));
     350             :   }
     351             : }
     352             : 
     353             : // -----------------------------------------------------------------------------
     354             : // CheckedFloat64ToInt32
     355             : 
     356       15375 : TEST_F(SimplifiedOperatorReducerTest, CheckedFloat64ToInt32WithConstant) {
     357             :   Node* effect = graph()->start();
     358             :   Node* control = graph()->start();
     359         401 :   TRACED_FOREACH(int32_t, n, kInt32Values) {
     360             :     Reduction r = Reduce(graph()->NewNode(
     361             :         simplified()->CheckedFloat64ToInt32(
     362             :             CheckForMinusZeroMode::kDontCheckForMinusZero, VectorSlotPair()),
     363         300 :         Float64Constant(n), effect, control));
     364         100 :     ASSERT_TRUE(r.Changed());
     365         500 :     EXPECT_THAT(r.replacement(), IsInt32Constant(n));
     366             :   }
     367             : }
     368             : 
     369             : // -----------------------------------------------------------------------------
     370             : // CheckHeapObject
     371             : 
     372       15375 : TEST_F(SimplifiedOperatorReducerTest, CheckHeapObjectWithChangeBitToTagged) {
     373           1 :   Node* param0 = Parameter(0);
     374             :   Node* effect = graph()->start();
     375             :   Node* control = graph()->start();
     376           2 :   Node* value = graph()->NewNode(simplified()->ChangeBitToTagged(), param0);
     377             :   Reduction reduction = Reduce(graph()->NewNode(simplified()->CheckHeapObject(),
     378           2 :                                                 value, effect, control));
     379           1 :   ASSERT_TRUE(reduction.Changed());
     380           2 :   EXPECT_EQ(value, reduction.replacement());
     381             : }
     382             : 
     383       15375 : TEST_F(SimplifiedOperatorReducerTest, CheckHeapObjectWithHeapConstant) {
     384             :   Node* effect = graph()->start();
     385             :   Node* control = graph()->start();
     386             :   Handle<HeapObject> kHeapObjects[] = {
     387             :       factory()->empty_string(), factory()->null_value(),
     388             :       factory()->species_symbol(), factory()->undefined_value()};
     389          17 :   TRACED_FOREACH(Handle<HeapObject>, object, kHeapObjects) {
     390           4 :     Node* value = HeapConstant(object);
     391             :     Reduction reduction = Reduce(graph()->NewNode(
     392           8 :         simplified()->CheckHeapObject(), value, effect, control));
     393           4 :     ASSERT_TRUE(reduction.Changed());
     394           8 :     EXPECT_EQ(value, reduction.replacement());
     395             :   }
     396             : }
     397             : 
     398       15375 : TEST_F(SimplifiedOperatorReducerTest, CheckHeapObjectWithCheckHeapObject) {
     399           1 :   Node* param0 = Parameter(0);
     400             :   Node* effect = graph()->start();
     401             :   Node* control = graph()->start();
     402           1 :   Node* value = effect = graph()->NewNode(simplified()->CheckHeapObject(),
     403           1 :                                           param0, effect, control);
     404             :   Reduction reduction = Reduce(graph()->NewNode(simplified()->CheckHeapObject(),
     405           2 :                                                 value, effect, control));
     406           1 :   ASSERT_TRUE(reduction.Changed());
     407           2 :   EXPECT_EQ(value, reduction.replacement());
     408             : }
     409             : 
     410             : // -----------------------------------------------------------------------------
     411             : // CheckSmi
     412             : 
     413       15375 : TEST_F(SimplifiedOperatorReducerTest, CheckSmiWithChangeInt31ToTaggedSigned) {
     414           1 :   Node* param0 = Parameter(0);
     415             :   Node* effect = graph()->start();
     416             :   Node* control = graph()->start();
     417             :   Node* value =
     418           2 :       graph()->NewNode(simplified()->ChangeInt31ToTaggedSigned(), param0);
     419             :   Reduction reduction = Reduce(graph()->NewNode(
     420           2 :       simplified()->CheckSmi(VectorSlotPair()), value, effect, control));
     421           1 :   ASSERT_TRUE(reduction.Changed());
     422           2 :   EXPECT_EQ(value, reduction.replacement());
     423             : }
     424             : 
     425       15375 : TEST_F(SimplifiedOperatorReducerTest, CheckSmiWithNumberConstant) {
     426             :   Node* effect = graph()->start();
     427             :   Node* control = graph()->start();
     428           1 :   Node* value = NumberConstant(1.0);
     429             :   Reduction reduction = Reduce(graph()->NewNode(
     430           3 :       simplified()->CheckSmi(VectorSlotPair()), value, effect, control));
     431           1 :   ASSERT_TRUE(reduction.Changed());
     432           2 :   EXPECT_EQ(value, reduction.replacement());
     433             : }
     434             : 
     435       15375 : TEST_F(SimplifiedOperatorReducerTest, CheckSmiWithCheckSmi) {
     436           1 :   Node* param0 = Parameter(0);
     437             :   Node* effect = graph()->start();
     438             :   Node* control = graph()->start();
     439           3 :   Node* value = effect = graph()->NewNode(
     440           1 :       simplified()->CheckSmi(VectorSlotPair()), param0, effect, control);
     441             :   Reduction reduction = Reduce(graph()->NewNode(
     442           2 :       simplified()->CheckSmi(VectorSlotPair()), value, effect, control));
     443           1 :   ASSERT_TRUE(reduction.Changed());
     444           2 :   EXPECT_EQ(value, reduction.replacement());
     445             : }
     446             : 
     447             : // -----------------------------------------------------------------------------
     448             : // NumberAbs
     449             : 
     450       15375 : TEST_F(SimplifiedOperatorReducerTest, NumberAbsWithNumberConstant) {
     451         401 :   TRACED_FOREACH(double, n, kFloat64Values) {
     452             :     Reduction reduction =
     453         300 :         Reduce(graph()->NewNode(simplified()->NumberAbs(), NumberConstant(n)));
     454         100 :     ASSERT_TRUE(reduction.Changed());
     455         500 :     EXPECT_THAT(reduction.replacement(), IsNumberConstant(std::fabs(n)));
     456             :   }
     457             : }
     458             : 
     459             : // -----------------------------------------------------------------------------
     460             : // ObjectIsSmi
     461             : 
     462       15375 : TEST_F(SimplifiedOperatorReducerTest, ObjectIsSmiWithChangeBitToTagged) {
     463           1 :   Node* param0 = Parameter(0);
     464             :   Reduction reduction = Reduce(graph()->NewNode(
     465             :       simplified()->ObjectIsSmi(),
     466           3 :       graph()->NewNode(simplified()->ChangeBitToTagged(), param0)));
     467           1 :   ASSERT_TRUE(reduction.Changed());
     468           4 :   EXPECT_THAT(reduction.replacement(), IsFalseConstant());
     469             : }
     470             : 
     471       15375 : TEST_F(SimplifiedOperatorReducerTest,
     472             :        ObjectIsSmiWithChangeInt31ToTaggedSigned) {
     473           1 :   Node* param0 = Parameter(0);
     474             :   Reduction reduction = Reduce(graph()->NewNode(
     475             :       simplified()->ObjectIsSmi(),
     476           3 :       graph()->NewNode(simplified()->ChangeInt31ToTaggedSigned(), param0)));
     477           1 :   ASSERT_TRUE(reduction.Changed());
     478           4 :   EXPECT_THAT(reduction.replacement(), IsTrueConstant());
     479             : }
     480             : 
     481       12301 : TEST_F(SimplifiedOperatorReducerTest, ObjectIsSmiWithHeapConstant) {
     482             :   Handle<HeapObject> kHeapObjects[] = {
     483             :       factory()->empty_string(), factory()->null_value(),
     484             :       factory()->species_symbol(), factory()->undefined_value()};
     485          17 :   TRACED_FOREACH(Handle<HeapObject>, o, kHeapObjects) {
     486             :     Reduction reduction =
     487          12 :         Reduce(graph()->NewNode(simplified()->ObjectIsSmi(), HeapConstant(o)));
     488           4 :     ASSERT_TRUE(reduction.Changed());
     489          16 :     EXPECT_THAT(reduction.replacement(), IsFalseConstant());
     490             :   }
     491             : }
     492             : 
     493       15375 : TEST_F(SimplifiedOperatorReducerTest, ObjectIsSmiWithNumberConstant) {
     494         401 :   TRACED_FOREACH(double, n, kFloat64Values) {
     495             :     Reduction reduction = Reduce(
     496         300 :         graph()->NewNode(simplified()->ObjectIsSmi(), NumberConstant(n)));
     497         100 :     ASSERT_TRUE(reduction.Changed());
     498         500 :     EXPECT_THAT(reduction.replacement(), IsBooleanConstant(IsSmiDouble(n)));
     499             :   }
     500             : }
     501             : 
     502             : }  // namespace simplified_operator_reducer_unittest
     503             : }  // namespace compiler
     504             : }  // namespace internal
     505        9222 : }  // namespace v8

Generated by: LCOV version 1.10