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/common-operator.h"
       6             : #include "src/compiler/diamond.h"
       7             : #include "test/unittests/compiler/graph-unittest.h"
       8             : #include "test/unittests/compiler/node-test-utils.h"
       9             : #include "testing/gmock-support.h"
      10             : 
      11             : using testing::AllOf;
      12             : using testing::Capture;
      13             : using testing::CaptureEq;
      14             : 
      15             : namespace v8 {
      16             : namespace internal {
      17             : namespace compiler {
      18             : 
      19           8 : class DiamondTest : public GraphTest {
      20             :  public:
      21           8 :   DiamondTest() : GraphTest(5) {}
      22             : };
      23             : 
      24             : 
      25       15419 : TEST_F(DiamondTest, SimpleDiamond) {
      26           1 :   Node* p = Parameter(0);
      27           1 :   Diamond d(graph(), common(), p);
      28           6 :   EXPECT_THAT(d.branch, IsBranch(p, graph()->start()));
      29           5 :   EXPECT_THAT(d.if_true, IsIfTrue(d.branch));
      30           5 :   EXPECT_THAT(d.if_false, IsIfFalse(d.branch));
      31           6 :   EXPECT_THAT(d.merge, IsMerge(d.if_true, d.if_false));
      32           1 : }
      33             : 
      34             : 
      35       15419 : TEST_F(DiamondTest, DiamondChainDiamond) {
      36           1 :   Node* p0 = Parameter(0);
      37           1 :   Node* p1 = Parameter(1);
      38           1 :   Diamond d0(graph(), common(), p0);
      39           1 :   Diamond d1(graph(), common(), p1);
      40             :   d1.Chain(d0);
      41           6 :   EXPECT_THAT(d1.branch, IsBranch(p1, d0.merge));
      42           6 :   EXPECT_THAT(d0.branch, IsBranch(p0, graph()->start()));
      43           1 : }
      44             : 
      45             : 
      46       15419 : TEST_F(DiamondTest, DiamondChainNode) {
      47           1 :   Node* p1 = Parameter(1);
      48           1 :   Diamond d1(graph(), common(), p1);
      49           1 :   Node* other = graph()->NewNode(common()->Merge(0));
      50             :   d1.Chain(other);
      51           6 :   EXPECT_THAT(d1.branch, IsBranch(p1, other));
      52           1 : }
      53             : 
      54             : 
      55       15419 : TEST_F(DiamondTest, DiamondChainN) {
      56           4 :   Node* params[5] = {Parameter(0), Parameter(1), Parameter(2), Parameter(3),
      57           4 :                      Parameter(4)};
      58             :   Diamond d[5] = {Diamond(graph(), common(), params[0]),
      59             :                   Diamond(graph(), common(), params[1]),
      60             :                   Diamond(graph(), common(), params[2]),
      61             :                   Diamond(graph(), common(), params[3]),
      62           1 :                   Diamond(graph(), common(), params[4])};
      63             : 
      64           9 :   for (int i = 1; i < 5; i++) {
      65           4 :     d[i].Chain(d[i - 1]);
      66          24 :     EXPECT_THAT(d[i].branch, IsBranch(params[i], d[i - 1].merge));
      67             :   }
      68           1 : }
      69             : 
      70             : 
      71       15419 : TEST_F(DiamondTest, DiamondNested_true) {
      72           1 :   Node* p0 = Parameter(0);
      73           1 :   Node* p1 = Parameter(1);
      74           1 :   Diamond d0(graph(), common(), p0);
      75           1 :   Diamond d1(graph(), common(), p1);
      76             : 
      77           1 :   d1.Nest(d0, true);
      78             : 
      79           6 :   EXPECT_THAT(d0.branch, IsBranch(p0, graph()->start()));
      80           5 :   EXPECT_THAT(d0.if_true, IsIfTrue(d0.branch));
      81           5 :   EXPECT_THAT(d0.if_false, IsIfFalse(d0.branch));
      82           6 :   EXPECT_THAT(d0.merge, IsMerge(d1.merge, d0.if_false));
      83             : 
      84           6 :   EXPECT_THAT(d1.branch, IsBranch(p1, d0.if_true));
      85           5 :   EXPECT_THAT(d1.if_true, IsIfTrue(d1.branch));
      86           5 :   EXPECT_THAT(d1.if_false, IsIfFalse(d1.branch));
      87           6 :   EXPECT_THAT(d1.merge, IsMerge(d1.if_true, d1.if_false));
      88           1 : }
      89             : 
      90             : 
      91       15419 : TEST_F(DiamondTest, DiamondNested_false) {
      92           1 :   Node* p0 = Parameter(0);
      93           1 :   Node* p1 = Parameter(1);
      94           1 :   Diamond d0(graph(), common(), p0);
      95           1 :   Diamond d1(graph(), common(), p1);
      96             : 
      97           1 :   d1.Nest(d0, false);
      98             : 
      99           6 :   EXPECT_THAT(d0.branch, IsBranch(p0, graph()->start()));
     100           5 :   EXPECT_THAT(d0.if_true, IsIfTrue(d0.branch));
     101           5 :   EXPECT_THAT(d0.if_false, IsIfFalse(d0.branch));
     102           6 :   EXPECT_THAT(d0.merge, IsMerge(d0.if_true, d1.merge));
     103             : 
     104           6 :   EXPECT_THAT(d1.branch, IsBranch(p1, d0.if_false));
     105           5 :   EXPECT_THAT(d1.if_true, IsIfTrue(d1.branch));
     106           5 :   EXPECT_THAT(d1.if_false, IsIfFalse(d1.branch));
     107           6 :   EXPECT_THAT(d1.merge, IsMerge(d1.if_true, d1.if_false));
     108           1 : }
     109             : 
     110             : 
     111       15419 : TEST_F(DiamondTest, DiamondPhis) {
     112           1 :   Node* p0 = Parameter(0);
     113           1 :   Node* p1 = Parameter(1);
     114           1 :   Node* p2 = Parameter(2);
     115           1 :   Diamond d(graph(), common(), p0);
     116             : 
     117             :   MachineRepresentation types[] = {MachineRepresentation::kTagged,
     118           1 :                                    MachineRepresentation::kWord32};
     119             : 
     120           5 :   for (size_t i = 0; i < arraysize(types); i++) {
     121           2 :     Node* phi = d.Phi(types[i], p1, p2);
     122             : 
     123          12 :     EXPECT_THAT(d.branch, IsBranch(p0, graph()->start()));
     124          10 :     EXPECT_THAT(d.if_true, IsIfTrue(d.branch));
     125          10 :     EXPECT_THAT(d.if_false, IsIfFalse(d.branch));
     126          12 :     EXPECT_THAT(d.merge, IsMerge(d.if_true, d.if_false));
     127          16 :     EXPECT_THAT(phi, IsPhi(types[i], p1, p2, d.merge));
     128             :   }
     129           1 : }
     130             : 
     131             : 
     132       15419 : TEST_F(DiamondTest, BranchHint) {
     133           2 :   Diamond dn(graph(), common(), Parameter(0));
     134           1 :   CHECK_EQ(BranchHint::kNone, BranchHintOf(dn.branch->op()));
     135             : 
     136           1 :   Diamond dt(graph(), common(), Parameter(0), BranchHint::kTrue);
     137           1 :   CHECK_EQ(BranchHint::kTrue, BranchHintOf(dt.branch->op()));
     138             : 
     139           1 :   Diamond df(graph(), common(), Parameter(0), BranchHint::kFalse);
     140           1 :   CHECK_EQ(BranchHint::kFalse, BranchHintOf(df.branch->op()));
     141           1 : }
     142             : 
     143             : 
     144             : }  // namespace compiler
     145             : }  // namespace internal
     146        9249 : }  // namespace v8