LCOV - code coverage report
Current view: top level - test/unittests/compiler - node-unittest.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 184 184 100.0 %
Date: 2019-02-19 Functions: 28 41 68.3 %

          Line data    Source code
       1             : // Copyright 2015 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/node.h"
       6             : #include "src/compiler/operator.h"
       7             : #include "test/unittests/test-utils.h"
       8             : #include "testing/gmock-support.h"
       9             : 
      10             : using testing::Contains;
      11             : using testing::ElementsAre;
      12             : using testing::ElementsAreArray;
      13             : using testing::UnorderedElementsAre;
      14             : 
      15             : namespace v8 {
      16             : namespace internal {
      17             : namespace compiler {
      18             : namespace node_unittest {
      19             : 
      20             : typedef TestWithZone NodeTest;
      21             : 
      22             : 
      23             : const IrOpcode::Value kOpcode0 = static_cast<IrOpcode::Value>(0);
      24             : const IrOpcode::Value kOpcode1 = static_cast<IrOpcode::Value>(1);
      25             : const IrOpcode::Value kOpcode2 = static_cast<IrOpcode::Value>(2);
      26             : 
      27        3037 : const Operator kOp0(kOpcode0, Operator::kNoProperties, "Op0", 0, 0, 0, 1, 0, 0);
      28        3037 : const Operator kOp1(kOpcode1, Operator::kNoProperties, "Op1", 1, 0, 0, 1, 0, 0);
      29        3037 : const Operator kOp2(kOpcode2, Operator::kNoProperties, "Op2", 2, 0, 0, 1, 0, 0);
      30             : 
      31             : 
      32       15188 : TEST_F(NodeTest, New) {
      33           3 :   Node* const node = Node::New(zone(), 1, &kOp0, 0, nullptr, false);
      34           2 :   EXPECT_EQ(1U, node->id());
      35           2 :   EXPECT_EQ(0, node->UseCount());
      36           2 :   EXPECT_TRUE(node->uses().empty());
      37           2 :   EXPECT_EQ(0, node->InputCount());
      38           1 :   EXPECT_TRUE(node->inputs().empty());
      39           2 :   EXPECT_EQ(&kOp0, node->op());
      40           2 :   EXPECT_EQ(kOpcode0, node->opcode());
      41           1 : }
      42             : 
      43             : 
      44       15188 : TEST_F(NodeTest, NewWithInputs) {
      45           1 :   Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false);
      46           2 :   EXPECT_EQ(0, n0->UseCount());
      47           3 :   EXPECT_EQ(0, n0->InputCount());
      48           1 :   Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false);
      49           2 :   EXPECT_EQ(1, n0->UseCount());
      50           2 :   EXPECT_THAT(n0->uses(), UnorderedElementsAre(n1));
      51           2 :   EXPECT_EQ(0, n1->UseCount());
      52           3 :   EXPECT_EQ(1, n1->InputCount());
      53           3 :   EXPECT_EQ(n0, n1->InputAt(0));
      54           1 :   Node* n0_n1[] = {n0, n1};
      55           1 :   Node* n2 = Node::New(zone(), 2, &kOp2, 2, n0_n1, false);
      56           2 :   EXPECT_EQ(2, n0->UseCount());
      57           2 :   EXPECT_THAT(n0->uses(), UnorderedElementsAre(n1, n2));
      58           2 :   EXPECT_THAT(n1->uses(), UnorderedElementsAre(n2));
      59           2 :   EXPECT_EQ(2, n2->InputCount());
      60           2 :   EXPECT_EQ(n0, n2->InputAt(0));
      61           2 :   EXPECT_EQ(n1, n2->InputAt(1));
      62           1 : }
      63             : 
      64             : 
      65       15188 : TEST_F(NodeTest, InputIteratorEmpty) {
      66           1 :   Node* node = Node::New(zone(), 0, &kOp0, 0, nullptr, false);
      67           3 :   EXPECT_EQ(node->inputs().begin(), node->inputs().end());
      68           1 : }
      69             : 
      70             : 
      71       15188 : TEST_F(NodeTest, InputIteratorOne) {
      72           1 :   Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false);
      73           1 :   Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false);
      74           2 :   EXPECT_THAT(n1->inputs(), ElementsAre(n0));
      75           1 : }
      76             : 
      77             : 
      78       15188 : TEST_F(NodeTest, InputIteratorTwo) {
      79           1 :   Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false);
      80           1 :   Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false);
      81           1 :   Node* n0_n1[] = {n0, n1};
      82           1 :   Node* n2 = Node::New(zone(), 2, &kOp2, 2, n0_n1, false);
      83           2 :   EXPECT_THAT(n2->inputs(), ElementsAre(n0, n1));
      84           1 : }
      85             : 
      86             : 
      87       15188 : TEST_F(NodeTest, UseIteratorEmpty) {
      88           1 :   Node* node = Node::New(zone(), 0, &kOp0, 0, nullptr, false);
      89           3 :   EXPECT_EQ(node->uses().begin(), node->uses().end());
      90           1 : }
      91             : 
      92             : 
      93       15188 : TEST_F(NodeTest, UseIteratorOne) {
      94           1 :   Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false);
      95           1 :   Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false);
      96           2 :   EXPECT_THAT(n0->uses(), ElementsAre(n1));
      97           1 : }
      98             : 
      99             : 
     100       15188 : TEST_F(NodeTest, UseIteratorTwo) {
     101           1 :   Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false);
     102           1 :   Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false);
     103           1 :   Node* n0_n1[] = {n0, n1};
     104           1 :   Node* n2 = Node::New(zone(), 2, &kOp2, 2, n0_n1, false);
     105           2 :   EXPECT_THAT(n0->uses(), UnorderedElementsAre(n1, n2));
     106           1 : }
     107             : 
     108             : 
     109       15188 : TEST_F(NodeTest, OwnedBy) {
     110           1 :   Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false);
     111           9 :   EXPECT_FALSE(n0->OwnedBy(n0));
     112           6 :   Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false);
     113           3 :   EXPECT_FALSE(n0->OwnedBy(n0));
     114           2 :   EXPECT_FALSE(n1->OwnedBy(n1));
     115           3 :   EXPECT_TRUE(n0->OwnedBy(n1));
     116           1 :   Node* n0_n1[] = {n0, n1};
     117           2 :   Node* n2 = Node::New(zone(), 2, &kOp2, 2, n0_n1, false);
     118           3 :   EXPECT_FALSE(n0->OwnedBy(n0));
     119           2 :   EXPECT_FALSE(n1->OwnedBy(n1));
     120           2 :   EXPECT_FALSE(n2->OwnedBy(n2));
     121           3 :   EXPECT_FALSE(n0->OwnedBy(n1));
     122           3 :   EXPECT_FALSE(n0->OwnedBy(n2));
     123           2 :   EXPECT_TRUE(n1->OwnedBy(n2));
     124           2 :   EXPECT_TRUE(n0->OwnedBy(n1, n2));
     125           1 :   n2->ReplaceInput(0, n2);
     126           3 :   EXPECT_TRUE(n0->OwnedBy(n1));
     127           2 :   EXPECT_TRUE(n1->OwnedBy(n2));
     128           1 :   n2->ReplaceInput(1, n0);
     129           3 :   EXPECT_FALSE(n0->OwnedBy(n1));
     130           2 :   EXPECT_FALSE(n1->OwnedBy(n2));
     131           1 : }
     132             : 
     133             : 
     134       15188 : TEST_F(NodeTest, ReplaceUsesNone) {
     135           1 :   Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false);
     136           1 :   Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false);
     137           1 :   Node* n0_n1[] = {n0, n1};
     138           1 :   Node* n2 = Node::New(zone(), 2, &kOp2, 2, n0_n1, false);
     139           1 :   Node* node = Node::New(zone(), 42, &kOp0, 0, nullptr, false);
     140           2 :   EXPECT_TRUE(node->uses().empty());
     141           1 :   node->ReplaceUses(n0);
     142           2 :   EXPECT_TRUE(node->uses().empty());
     143           1 :   node->ReplaceUses(n1);
     144           2 :   EXPECT_TRUE(node->uses().empty());
     145           1 :   node->ReplaceUses(n2);
     146           2 :   EXPECT_TRUE(node->uses().empty());
     147           1 : }
     148             : 
     149             : 
     150       15188 : TEST_F(NodeTest, AppendInput) {
     151           1 :   Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false);
     152           1 :   Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false);
     153           1 :   Node* node = Node::New(zone(), 12345, &kOp0, 0, nullptr, true);
     154           1 :   EXPECT_TRUE(node->inputs().empty());
     155           1 :   node->AppendInput(zone(), n0);
     156           2 :   EXPECT_FALSE(node->inputs().empty());
     157           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n0));
     158           1 :   node->AppendInput(zone(), n1);
     159           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n0, n1));
     160           1 :   node->AppendInput(zone(), n0);
     161           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n0, n1, n0));
     162           1 :   node->AppendInput(zone(), n0);
     163           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n0, n1, n0, n0));
     164           1 :   node->AppendInput(zone(), n1);
     165           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n0, n1, n0, n0, n1));
     166           1 : }
     167             : 
     168             : 
     169       15188 : TEST_F(NodeTest, TrimThenAppend) {
     170           1 :   Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false);
     171           1 :   Node* n1 = Node::New(zone(), 1, &kOp0, 0, nullptr, false);
     172           1 :   Node* n2 = Node::New(zone(), 2, &kOp0, 0, nullptr, false);
     173           1 :   Node* n3 = Node::New(zone(), 3, &kOp0, 0, nullptr, false);
     174           1 :   Node* n4 = Node::New(zone(), 4, &kOp0, 0, nullptr, false);
     175           1 :   Node* n5 = Node::New(zone(), 5, &kOp0, 0, nullptr, false);
     176           1 :   Node* n6 = Node::New(zone(), 6, &kOp0, 0, nullptr, false);
     177           1 :   Node* n7 = Node::New(zone(), 7, &kOp0, 0, nullptr, false);
     178           1 :   Node* n8 = Node::New(zone(), 8, &kOp0, 0, nullptr, false);
     179           1 :   Node* n9 = Node::New(zone(), 9, &kOp0, 0, nullptr, false);
     180           1 :   Node* node = Node::New(zone(), 12345, &kOp0, 0, nullptr, true);
     181             : 
     182           1 :   EXPECT_TRUE(node->inputs().empty());
     183             : 
     184           1 :   node->AppendInput(zone(), n0);
     185           2 :   EXPECT_FALSE(node->inputs().empty());
     186           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n0));
     187             : 
     188           1 :   node->TrimInputCount(0);
     189           1 :   EXPECT_TRUE(node->inputs().empty());
     190             : 
     191           1 :   node->AppendInput(zone(), n1);
     192           2 :   EXPECT_FALSE(node->inputs().empty());
     193           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n1));
     194             : 
     195           1 :   node->AppendInput(zone(), n2);
     196           2 :   EXPECT_FALSE(node->inputs().empty());
     197           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n1, n2));
     198             : 
     199           1 :   node->TrimInputCount(1);
     200           2 :   EXPECT_FALSE(node->inputs().empty());
     201           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n1));
     202             : 
     203           1 :   node->AppendInput(zone(), n3);
     204           2 :   EXPECT_FALSE(node->inputs().empty());
     205           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n1, n3));
     206             : 
     207           1 :   node->AppendInput(zone(), n4);
     208           2 :   EXPECT_FALSE(node->inputs().empty());
     209           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n1, n3, n4));
     210             : 
     211           1 :   node->AppendInput(zone(), n5);
     212           2 :   EXPECT_FALSE(node->inputs().empty());
     213           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n1, n3, n4, n5));
     214             : 
     215           1 :   node->AppendInput(zone(), n6);
     216           2 :   EXPECT_FALSE(node->inputs().empty());
     217           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n1, n3, n4, n5, n6));
     218             : 
     219           1 :   node->AppendInput(zone(), n7);
     220           2 :   EXPECT_FALSE(node->inputs().empty());
     221           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n1, n3, n4, n5, n6, n7));
     222             : 
     223           1 :   node->TrimInputCount(4);
     224           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n1, n3, n4, n5));
     225             : 
     226           1 :   node->AppendInput(zone(), n8);
     227           2 :   EXPECT_FALSE(node->inputs().empty());
     228           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n1, n3, n4, n5, n8));
     229             : 
     230           1 :   node->AppendInput(zone(), n9);
     231           2 :   EXPECT_FALSE(node->inputs().empty());
     232           2 :   EXPECT_THAT(node->inputs(), ElementsAre(n1, n3, n4, n5, n8, n9));
     233           1 : }
     234             : 
     235             : 
     236       15188 : TEST_F(NodeTest, BigNodes) {
     237             :   static const int kMaxSize = 512;
     238             :   Node* inputs[kMaxSize];
     239             : 
     240           1 :   Node* n0 = Node::New(zone(), 0, &kOp0, 0, nullptr, false);
     241           1 :   Node* n1 = Node::New(zone(), 1, &kOp1, 1, &n0, false);
     242             : 
     243         513 :   for (int i = 0; i < kMaxSize; i++) {
     244         512 :     inputs[i] = i & 1 ? n0 : n1;
     245             :   }
     246             : 
     247          57 :   for (int size = 13; size <= kMaxSize; size += 9) {
     248          56 :     Node* node = Node::New(zone(), 12345, &kOp0, size, inputs, false);
     249         112 :     EXPECT_EQ(size, node->InputCount());
     250             : 
     251       14644 :     for (int i = 0; i < size; i++) {
     252       29176 :       EXPECT_EQ(inputs[i], node->InputAt(i));
     253             :     }
     254             : 
     255          56 :     EXPECT_THAT(n0->uses(), Contains(node));
     256          56 :     EXPECT_THAT(n1->uses(), Contains(node));
     257         224 :     EXPECT_THAT(node->inputs(), ElementsAreArray(inputs, size));
     258             :   }
     259           1 : }
     260             : 
     261             : }  // namespace node_unittest
     262             : }  // namespace compiler
     263             : }  // namespace internal
     264        9111 : }  // namespace v8

Generated by: LCOV version 1.10