src/v8/test/cctest/compiler/test-node.cc

   1 // Copyright 2013 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 <functional>
   6
   7 #include "src/v8.h"
   8
   9 #include "graph-tester.h"
  10 #include "src/compiler/generic-node-inl.h"
  11 #include "src/compiler/node.h"
  12 #include "src/compiler/operator.h"
  13
  14 using namespace v8::internal;
  15 using namespace v8::internal::compiler;
  16
  17 static SimpleOperator dummy_operator(IrOpcode::kParameter, Operator::kNoWrite,
  18                                      0, 0, "dummy");
  19
  20 TEST(NodeAllocation) {
  21   GraphTester graph;
  22   Node* n1 = graph.NewNode(&dummy_operator);
  23   Node* n2 = graph.NewNode(&dummy_operator);
  24   CHECK(n2->id() != n1->id());
  25 }
  26
  27
  28 TEST(NodeWithOpcode) {
  29   GraphTester graph;
  30   Node* n1 = graph.NewNode(&dummy_operator);
  31   Node* n2 = graph.NewNode(&dummy_operator);
  32   CHECK(n1->op() == &dummy_operator);
  33   CHECK(n2->op() == &dummy_operator);
  34 }
  35
  36
  37 TEST(NodeInputs1) {
  38   GraphTester graph;
  39   Node* n0 = graph.NewNode(&dummy_operator);
  40   Node* n2 = graph.NewNode(&dummy_operator, n0);
  41   CHECK_EQ(1, n2->InputCount());
  42   CHECK(n0 == n2->InputAt(0));
  43 }
  44
  45
  46 TEST(NodeInputs2) {
  47   GraphTester graph;
  48   Node* n0 = graph.NewNode(&dummy_operator);
  49   Node* n1 = graph.NewNode(&dummy_operator);
  50   Node* n2 = graph.NewNode(&dummy_operator, n0, n1);
  51   CHECK_EQ(2, n2->InputCount());
  52   CHECK(n0 == n2->InputAt(0));
  53   CHECK(n1 == n2->InputAt(1));
  54 }
  55
  56
  57 TEST(NodeInputs3) {
  58   GraphTester graph;
  59   Node* n0 = graph.NewNode(&dummy_operator);
  60   Node* n1 = graph.NewNode(&dummy_operator);
  61   Node* n2 = graph.NewNode(&dummy_operator, n0, n1, n1);
  62   CHECK_EQ(3, n2->InputCount());
  63   CHECK(n0 == n2->InputAt(0));
  64   CHECK(n1 == n2->InputAt(1));
  65   CHECK(n1 == n2->InputAt(2));
  66 }
  67
  68
  69 TEST(NodeInputIteratorEmpty) {
  70   GraphTester graph;
  71   Node* n1 = graph.NewNode(&dummy_operator);
  72   Node::Inputs::iterator i(n1->inputs().begin());
  73   int input_count = 0;
  74   for (; i != n1->inputs().end(); ++i) {
  75     input_count++;
  76   }
  77   CHECK_EQ(0, input_count);
  78 }
  79
  80
  81 TEST(NodeInputIteratorOne) {
  82   GraphTester graph;
  83   Node* n0 = graph.NewNode(&dummy_operator);
  84   Node* n1 = graph.NewNode(&dummy_operator, n0);
  85   Node::Inputs::iterator i(n1->inputs().begin());
  86   CHECK_EQ(1, n1->InputCount());
  87   CHECK_EQ(n0, *i);
  88   ++i;
  89   CHECK(n1->inputs().end() == i);
  90 }
  91
  92
  93 TEST(NodeUseIteratorEmpty) {
  94   GraphTester graph;
  95   Node* n1 = graph.NewNode(&dummy_operator);
  96   Node::Uses::iterator i(n1->uses().begin());
  97   int use_count = 0;
  98   for (; i != n1->uses().end(); ++i) {
  99     Node::Edge edge(i.edge());
 100     USE(edge);
 101     use_count++;
 102   }
 103   CHECK_EQ(0, use_count);
 104 }
 105
 106
 107 TEST(NodeUseIteratorOne) {
 108   GraphTester graph;
 109   Node* n0 = graph.NewNode(&dummy_operator);
 110   Node* n1 = graph.NewNode(&dummy_operator, n0);
 111   Node::Uses::iterator i(n0->uses().begin());
 112   CHECK_EQ(n1, *i);
 113   ++i;
 114   CHECK(n0->uses().end() == i);
 115 }
 116
 117
 118 TEST(NodeUseIteratorReplaceNoUses) {
 119   GraphTester graph;
 120   Node* n0 = graph.NewNode(&dummy_operator);
 121   Node* n3 = graph.NewNode(&dummy_operator);
 122   n0->ReplaceUses(n3);
 123   CHECK(n0->uses().begin() == n0->uses().end());
 124 }
 125
 126
 127 TEST(NodeUseIteratorReplaceUses) {
 128   GraphTester graph;
 129   Node* n0 = graph.NewNode(&dummy_operator);
 130   Node* n1 = graph.NewNode(&dummy_operator, n0);
 131   Node* n2 = graph.NewNode(&dummy_operator, n0);
 132   Node* n3 = graph.NewNode(&dummy_operator);
 133   Node::Uses::iterator i1(n0->uses().begin());
 134   CHECK_EQ(n1, *i1);
 135   ++i1;
 136   CHECK_EQ(n2, *i1);
 137   n0->ReplaceUses(n3);
 138   Node::Uses::iterator i2(n3->uses().begin());
 139   CHECK_EQ(n1, *i2);
 140   ++i2;
 141   CHECK_EQ(n2, *i2);
 142   Node::Inputs::iterator i3(n1->inputs().begin());
 143   CHECK_EQ(n3, *i3);
 144   ++i3;
 145   CHECK(n1->inputs().end() == i3);
 146   Node::Inputs::iterator i4(n2->inputs().begin());
 147   CHECK_EQ(n3, *i4);
 148   ++i4;
 149   CHECK(n2->inputs().end() == i4);
 150 }
 151
 152
 153 TEST(NodeUseIteratorReplaceUsesSelf) {
 154   GraphTester graph;
 155   Node* n0 = graph.NewNode(&dummy_operator);
 156   Node* n1 = graph.NewNode(&dummy_operator, n0);
 157   Node* n3 = graph.NewNode(&dummy_operator);
 158
 159   n1->ReplaceInput(0, n1);  // Create self-reference.
 160
 161   Node::Uses::iterator i1(n1->uses().begin());
 162   CHECK_EQ(n1, *i1);
 163
 164   n1->ReplaceUses(n3);
 165
 166   CHECK(n1->uses().begin() == n1->uses().end());
 167
 168   Node::Uses::iterator i2(n3->uses().begin());
 169   CHECK_EQ(n1, *i2);
 170   ++i2;
 171   CHECK(n1->uses().end() == i2);
 172 }
 173
 174
 175 TEST(ReplaceInput) {
 176   GraphTester graph;
 177   Node* n0 = graph.NewNode(&dummy_operator);
 178   Node* n1 = graph.NewNode(&dummy_operator);
 179   Node* n2 = graph.NewNode(&dummy_operator);
 180   Node* n3 = graph.NewNode(&dummy_operator, n0, n1, n2);
 181   Node::Inputs::iterator i1(n3->inputs().begin());
 182   CHECK(n0 == *i1);
 183   CHECK_EQ(n0, n3->InputAt(0));
 184   ++i1;
 185   CHECK_EQ(n1, *i1);
 186   CHECK_EQ(n1, n3->InputAt(1));
 187   ++i1;
 188   CHECK_EQ(n2, *i1);
 189   CHECK_EQ(n2, n3->InputAt(2));
 190   ++i1;
 191   CHECK(i1 == n3->inputs().end());
 192
 193   Node::Uses::iterator i2(n1->uses().begin());
 194   CHECK_EQ(n3, *i2);
 195   ++i2;
 196   CHECK(i2 == n1->uses().end());
 197
 198   Node* n4 = graph.NewNode(&dummy_operator);
 199   Node::Uses::iterator i3(n4->uses().begin());
 200   CHECK(i3 == n4->uses().end());
 201
 202   n3->ReplaceInput(1, n4);
 203
 204   Node::Uses::iterator i4(n1->uses().begin());
 205   CHECK(i4 == n1->uses().end());
 206
 207   Node::Uses::iterator i5(n4->uses().begin());
 208   CHECK_EQ(n3, *i5);
 209   ++i5;
 210   CHECK(i5 == n4->uses().end());
 211
 212   Node::Inputs::iterator i6(n3->inputs().begin());
 213   CHECK(n0 == *i6);
 214   CHECK_EQ(n0, n3->InputAt(0));
 215   ++i6;
 216   CHECK_EQ(n4, *i6);
 217   CHECK_EQ(n4, n3->InputAt(1));
 218   ++i6;
 219   CHECK_EQ(n2, *i6);
 220   CHECK_EQ(n2, n3->InputAt(2));
 221   ++i6;
 222   CHECK(i6 == n3->inputs().end());
 223 }
 224
 225
 226 TEST(OwnedBy) {
 227   GraphTester graph;
 228
 229   {
 230     Node* n0 = graph.NewNode(&dummy_operator);
 231     Node* n1 = graph.NewNode(&dummy_operator);
 232
 233     CHECK(!n0->OwnedBy(n1));
 234     CHECK(!n1->OwnedBy(n0));
 235
 236     Node* n2 = graph.NewNode(&dummy_operator, n0);
 237     CHECK(n0->OwnedBy(n2));
 238     CHECK(!n2->OwnedBy(n0));
 239
 240     Node* n3 = graph.NewNode(&dummy_operator, n0);
 241     CHECK(!n0->OwnedBy(n2));
 242     CHECK(!n0->OwnedBy(n3));
 243     CHECK(!n2->OwnedBy(n0));
 244     CHECK(!n3->OwnedBy(n0));
 245   }
 246
 247   {
 248     Node* n0 = graph.NewNode(&dummy_operator);
 249     Node* n1 = graph.NewNode(&dummy_operator, n0);
 250     CHECK(n0->OwnedBy(n1));
 251     CHECK(!n1->OwnedBy(n0));
 252     Node* n2 = graph.NewNode(&dummy_operator, n0);
 253     CHECK(!n0->OwnedBy(n1));
 254     CHECK(!n0->OwnedBy(n2));
 255     CHECK(!n1->OwnedBy(n0));
 256     CHECK(!n1->OwnedBy(n2));
 257     CHECK(!n2->OwnedBy(n0));
 258     CHECK(!n2->OwnedBy(n1));
 259
 260     Node* n3 = graph.NewNode(&dummy_operator);
 261     n2->ReplaceInput(0, n3);
 262
 263     CHECK(n0->OwnedBy(n1));
 264     CHECK(!n1->OwnedBy(n0));
 265     CHECK(!n1->OwnedBy(n0));
 266     CHECK(!n1->OwnedBy(n2));
 267     CHECK(!n2->OwnedBy(n0));
 268     CHECK(!n2->OwnedBy(n1));
 269     CHECK(n3->OwnedBy(n2));
 270     CHECK(!n2->OwnedBy(n3));
 271   }
 272 }
 273
 274
 275 TEST(Uses) {
 276   GraphTester graph;
 277
 278   Node* n0 = graph.NewNode(&dummy_operator);
 279   Node* n1 = graph.NewNode(&dummy_operator, n0);
 280   CHECK_EQ(1, n0->UseCount());
 281   printf("A: %d vs %d\n", n0->UseAt(0)->id(), n1->id());
 282   CHECK(n0->UseAt(0) == n1);
 283   Node* n2 = graph.NewNode(&dummy_operator, n0);
 284   CHECK_EQ(2, n0->UseCount());
 285   printf("B: %d vs %d\n", n0->UseAt(1)->id(), n2->id());
 286   CHECK(n0->UseAt(1) == n2);
 287   Node* n3 = graph.NewNode(&dummy_operator, n0);
 288   CHECK_EQ(3, n0->UseCount());
 289   CHECK(n0->UseAt(2) == n3);
 290 }
 291
 292
 293 TEST(Inputs) {
 294   GraphTester graph;
 295
 296   Node* n0 = graph.NewNode(&dummy_operator);
 297   Node* n1 = graph.NewNode(&dummy_operator, n0);
 298   Node* n2 = graph.NewNode(&dummy_operator, n0);
 299   Node* n3 = graph.NewNode(&dummy_operator, n0, n1, n2);
 300   CHECK_EQ(3, n3->InputCount());
 301   CHECK(n3->InputAt(0) == n0);
 302   CHECK(n3->InputAt(1) == n1);
 303   CHECK(n3->InputAt(2) == n2);
 304   Node* n4 = graph.NewNode(&dummy_operator, n0, n1, n2);
 305   n3->AppendInput(graph.zone(), n4);
 306   CHECK_EQ(4, n3->InputCount());
 307   CHECK(n3->InputAt(0) == n0);
 308   CHECK(n3->InputAt(1) == n1);
 309   CHECK(n3->InputAt(2) == n2);
 310   CHECK(n3->InputAt(3) == n4);
 311   Node* n5 = graph.NewNode(&dummy_operator, n4);
 312   n3->AppendInput(graph.zone(), n4);
 313   CHECK_EQ(5, n3->InputCount());
 314   CHECK(n3->InputAt(0) == n0);
 315   CHECK(n3->InputAt(1) == n1);
 316   CHECK(n3->InputAt(2) == n2);
 317   CHECK(n3->InputAt(3) == n4);
 318   CHECK(n3->InputAt(4) == n4);
 319
 320   // Make sure uses have been hooked op correctly.
 321   Node::Uses uses(n4->uses());
 322   Node::Uses::iterator current = uses.begin();
 323   CHECK(current != uses.end());
 324   CHECK(*current == n3);
 325   ++current;
 326   CHECK(current != uses.end());
 327   CHECK(*current == n5);
 328   ++current;
 329   CHECK(current != uses.end());
 330   CHECK(*current == n3);
 331   ++current;
 332   CHECK(current == uses.end());
 333 }
 334
 335
 336 TEST(AppendInputsAndIterator) {
 337   GraphTester graph;
 338
 339   Node* n0 = graph.NewNode(&dummy_operator);
 340   Node* n1 = graph.NewNode(&dummy_operator, n0);
 341   Node* n2 = graph.NewNode(&dummy_operator, n0, n1);
 342
 343   Node::Inputs inputs(n2->inputs());
 344   Node::Inputs::iterator current = inputs.begin();
 345   CHECK(current != inputs.end());
 346   CHECK(*current == n0);
 347   ++current;
 348   CHECK(current != inputs.end());
 349   CHECK(*current == n1);
 350   ++current;
 351   CHECK(current == inputs.end());
 352
 353   Node* n3 = graph.NewNode(&dummy_operator);
 354   n2->AppendInput(graph.zone(), n3);
 355   inputs = n2->inputs();
 356   current = inputs.begin();
 357   CHECK(current != inputs.end());
 358   CHECK(*current == n0);
 359   CHECK_EQ(0, current.index());
 360   ++current;
 361   CHECK(current != inputs.end());
 362   CHECK(*current == n1);
 363   CHECK_EQ(1, current.index());
 364   ++current;
 365   CHECK(current != inputs.end());
 366   CHECK(*current == n3);
 367   CHECK_EQ(2, current.index());
 368   ++current;
 369   CHECK(current == inputs.end());
 370 }
 371
 372
 373 TEST(NullInputsSimple) {
 374   GraphTester graph;
 375
 376   Node* n0 = graph.NewNode(&dummy_operator);
 377   Node* n1 = graph.NewNode(&dummy_operator, n0);
 378   Node* n2 = graph.NewNode(&dummy_operator, n0, n1);
 379   CHECK_EQ(2, n2->InputCount());
 380
 381   CHECK(n0 == n2->InputAt(0));
 382   CHECK(n1 == n2->InputAt(1));
 383   CHECK_EQ(2, n0->UseCount());
 384   n2->ReplaceInput(0, NULL);
 385   CHECK(NULL == n2->InputAt(0));
 386   CHECK(n1 == n2->InputAt(1));
 387   CHECK_EQ(1, n0->UseCount());
 388 }
 389
 390
 391 TEST(NullInputsAppended) {
 392   GraphTester graph;
 393
 394   Node* n0 = graph.NewNode(&dummy_operator);
 395   Node* n1 = graph.NewNode(&dummy_operator, n0);
 396   Node* n2 = graph.NewNode(&dummy_operator, n0);
 397   Node* n3 = graph.NewNode(&dummy_operator, n0);
 398   n3->AppendInput(graph.zone(), n1);
 399   n3->AppendInput(graph.zone(), n2);
 400   CHECK_EQ(3, n3->InputCount());
 401
 402   CHECK(n0 == n3->InputAt(0));
 403   CHECK(n1 == n3->InputAt(1));
 404   CHECK(n2 == n3->InputAt(2));
 405   CHECK_EQ(1, n1->UseCount());
 406   n3->ReplaceInput(1, NULL);
 407   CHECK(n0 == n3->InputAt(0));
 408   CHECK(NULL == n3->InputAt(1));
 409   CHECK(n2 == n3->InputAt(2));
 410   CHECK_EQ(0, n1->UseCount());
 411 }
 412
 413
 414 TEST(ReplaceUsesFromAppendedInputs) {
 415   GraphTester graph;
 416
 417   Node* n0 = graph.NewNode(&dummy_operator);
 418   Node* n1 = graph.NewNode(&dummy_operator, n0);
 419   Node* n2 = graph.NewNode(&dummy_operator, n0);
 420   Node* n3 = graph.NewNode(&dummy_operator);
 421   n2->AppendInput(graph.zone(), n1);
 422   n2->AppendInput(graph.zone(), n0);
 423   CHECK_EQ(0, n3->UseCount());
 424   CHECK_EQ(3, n0->UseCount());
 425   n0->ReplaceUses(n3);
 426   CHECK_EQ(0, n0->UseCount());
 427   CHECK_EQ(3, n3->UseCount());
 428
 429   Node::Uses uses(n3->uses());
 430   Node::Uses::iterator current = uses.begin();
 431   CHECK(current != uses.end());
 432   CHECK(*current == n1);
 433   ++current;
 434   CHECK(current != uses.end());
 435   CHECK(*current == n2);
 436   ++current;
 437   CHECK(current != uses.end());
 438   CHECK(*current == n2);
 439   ++current;
 440   CHECK(current == uses.end());
 441 }
 442
 443
 444 template <bool result>
 445 struct FixedPredicate {
 446   bool operator()(const Node* node) const { return result; }
 447 };
 448
 449
 450 TEST(ReplaceUsesIfWithFixedPredicate) {
 451   GraphTester graph;
 452
 453   Node* n0 = graph.NewNode(&dummy_operator);
 454   Node* n1 = graph.NewNode(&dummy_operator, n0);
 455   Node* n2 = graph.NewNode(&dummy_operator, n0);
 456   Node* n3 = graph.NewNode(&dummy_operator);
 457
 458   CHECK_EQ(0, n2->UseCount());
 459   n2->ReplaceUsesIf(FixedPredicate<true>(), n1);
 460   CHECK_EQ(0, n2->UseCount());
 461   n2->ReplaceUsesIf(FixedPredicate<false>(), n1);
 462   CHECK_EQ(0, n2->UseCount());
 463
 464   CHECK_EQ(0, n3->UseCount());
 465   n3->ReplaceUsesIf(FixedPredicate<true>(), n1);
 466   CHECK_EQ(0, n3->UseCount());
 467   n3->ReplaceUsesIf(FixedPredicate<false>(), n1);
 468   CHECK_EQ(0, n3->UseCount());
 469
 470   CHECK_EQ(2, n0->UseCount());
 471   CHECK_EQ(0, n1->UseCount());
 472   n0->ReplaceUsesIf(FixedPredicate<false>(), n1);
 473   CHECK_EQ(2, n0->UseCount());
 474   CHECK_EQ(0, n1->UseCount());
 475   n0->ReplaceUsesIf(FixedPredicate<true>(), n1);
 476   CHECK_EQ(0, n0->UseCount());
 477   CHECK_EQ(2, n1->UseCount());
 478
 479   n1->AppendInput(graph.zone(), n1);
 480   CHECK_EQ(3, n1->UseCount());
 481   n1->AppendInput(graph.zone(), n3);
 482   CHECK_EQ(1, n3->UseCount());
 483   n3->ReplaceUsesIf(FixedPredicate<true>(), n1);
 484   CHECK_EQ(4, n1->UseCount());
 485   CHECK_EQ(0, n3->UseCount());
 486   n1->ReplaceUsesIf(FixedPredicate<false>(), n3);
 487   CHECK_EQ(4, n1->UseCount());
 488   CHECK_EQ(0, n3->UseCount());
 489 }
 490
 491
 492 TEST(ReplaceUsesIfWithEqualTo) {
 493   GraphTester graph;
 494
 495   Node* n0 = graph.NewNode(&dummy_operator);
 496   Node* n1 = graph.NewNode(&dummy_operator, n0);
 497   Node* n2 = graph.NewNode(&dummy_operator, n0, n1);
 498
 499   CHECK_EQ(0, n2->UseCount());
 500   n2->ReplaceUsesIf(std::bind1st(std::equal_to<Node*>(), n1), n0);
 501   CHECK_EQ(0, n2->UseCount());
 502
 503   CHECK_EQ(2, n0->UseCount());
 504   CHECK_EQ(1, n1->UseCount());
 505   n1->ReplaceUsesIf(std::bind1st(std::equal_to<Node*>(), n0), n0);
 506   CHECK_EQ(2, n0->UseCount());
 507   CHECK_EQ(1, n1->UseCount());
 508   n0->ReplaceUsesIf(std::bind2nd(std::equal_to<Node*>(), n2), n1);
 509   CHECK_EQ(1, n0->UseCount());
 510   CHECK_EQ(2, n1->UseCount());
 511 }
 512
 513
 514 TEST(ReplaceInputMultipleUses) {
 515   GraphTester graph;
 516
 517   Node* n0 = graph.NewNode(&dummy_operator);
 518   Node* n1 = graph.NewNode(&dummy_operator);
 519   Node* n2 = graph.NewNode(&dummy_operator, n0);
 520   n2->ReplaceInput(0, n1);
 521   CHECK_EQ(0, n0->UseCount());
 522   CHECK_EQ(1, n1->UseCount());
 523
 524   Node* n3 = graph.NewNode(&dummy_operator, n0);
 525   n3->ReplaceInput(0, n1);
 526   CHECK_EQ(0, n0->UseCount());
 527   CHECK_EQ(2, n1->UseCount());
 528 }
 529
 530
 531 TEST(TrimInputCountInline) {
 532   GraphTester graph;
 533
 534   {
 535     Node* n0 = graph.NewNode(&dummy_operator);
 536     Node* n1 = graph.NewNode(&dummy_operator, n0);
 537     n1->TrimInputCount(1);
 538     CHECK_EQ(1, n1->InputCount());
 539     CHECK_EQ(n0, n1->InputAt(0));
 540     CHECK_EQ(1, n0->UseCount());
 541   }
 542
 543   {
 544     Node* n0 = graph.NewNode(&dummy_operator);
 545     Node* n1 = graph.NewNode(&dummy_operator, n0);
 546     n1->TrimInputCount(0);
 547     CHECK_EQ(0, n1->InputCount());
 548     CHECK_EQ(0, n0->UseCount());
 549   }
 550
 551   {
 552     Node* n0 = graph.NewNode(&dummy_operator);
 553     Node* n1 = graph.NewNode(&dummy_operator);
 554     Node* n2 = graph.NewNode(&dummy_operator, n0, n1);
 555     n2->TrimInputCount(2);
 556     CHECK_EQ(2, n2->InputCount());
 557     CHECK_EQ(1, n0->UseCount());
 558     CHECK_EQ(1, n1->UseCount());
 559     CHECK_EQ(0, n2->UseCount());
 560   }
 561
 562   {
 563     Node* n0 = graph.NewNode(&dummy_operator);
 564     Node* n1 = graph.NewNode(&dummy_operator);
 565     Node* n2 = graph.NewNode(&dummy_operator, n0, n1);
 566     n2->TrimInputCount(1);
 567     CHECK_EQ(1, n2->InputCount());
 568     CHECK_EQ(1, n0->UseCount());
 569     CHECK_EQ(0, n1->UseCount());
 570     CHECK_EQ(0, n2->UseCount());
 571   }
 572
 573   {
 574     Node* n0 = graph.NewNode(&dummy_operator);
 575     Node* n1 = graph.NewNode(&dummy_operator);
 576     Node* n2 = graph.NewNode(&dummy_operator, n0, n1);
 577     n2->TrimInputCount(0);
 578     CHECK_EQ(0, n2->InputCount());
 579     CHECK_EQ(0, n0->UseCount());
 580     CHECK_EQ(0, n1->UseCount());
 581     CHECK_EQ(0, n2->UseCount());
 582   }
 583
 584   {
 585     Node* n0 = graph.NewNode(&dummy_operator);
 586     Node* n2 = graph.NewNode(&dummy_operator, n0, n0);
 587     n2->TrimInputCount(1);
 588     CHECK_EQ(1, n2->InputCount());
 589     CHECK_EQ(1, n0->UseCount());
 590     CHECK_EQ(0, n2->UseCount());
 591   }
 592
 593   {
 594     Node* n0 = graph.NewNode(&dummy_operator);
 595     Node* n2 = graph.NewNode(&dummy_operator, n0, n0);
 596     n2->TrimInputCount(0);
 597     CHECK_EQ(0, n2->InputCount());
 598     CHECK_EQ(0, n0->UseCount());
 599     CHECK_EQ(0, n2->UseCount());
 600   }
 601 }
 602
 603
 604 TEST(TrimInputCountOutOfLine1) {
 605   GraphTester graph;
 606
 607   {
 608     Node* n0 = graph.NewNode(&dummy_operator);
 609     Node* n1 = graph.NewNode(&dummy_operator);
 610     n1->AppendInput(graph.zone(), n0);
 611     n1->TrimInputCount(1);
 612     CHECK_EQ(1, n1->InputCount());
 613     CHECK_EQ(n0, n1->InputAt(0));
 614     CHECK_EQ(1, n0->UseCount());
 615   }
 616
 617   {
 618     Node* n0 = graph.NewNode(&dummy_operator);
 619     Node* n1 = graph.NewNode(&dummy_operator);
 620     n1->AppendInput(graph.zone(), n0);
 621     CHECK_EQ(1, n1->InputCount());
 622     n1->TrimInputCount(0);
 623     CHECK_EQ(0, n1->InputCount());
 624     CHECK_EQ(0, n0->UseCount());
 625   }
 626
 627   {
 628     Node* n0 = graph.NewNode(&dummy_operator);
 629     Node* n1 = graph.NewNode(&dummy_operator);
 630     Node* n2 = graph.NewNode(&dummy_operator);
 631     n2->AppendInput(graph.zone(), n0);
 632     n2->AppendInput(graph.zone(), n1);
 633     CHECK_EQ(2, n2->InputCount());
 634     n2->TrimInputCount(2);
 635     CHECK_EQ(2, n2->InputCount());
 636     CHECK_EQ(n0, n2->InputAt(0));
 637     CHECK_EQ(n1, n2->InputAt(1));
 638     CHECK_EQ(1, n0->UseCount());
 639     CHECK_EQ(1, n1->UseCount());
 640     CHECK_EQ(0, n2->UseCount());
 641   }
 642
 643   {
 644     Node* n0 = graph.NewNode(&dummy_operator);
 645     Node* n1 = graph.NewNode(&dummy_operator);
 646     Node* n2 = graph.NewNode(&dummy_operator);
 647     n2->AppendInput(graph.zone(), n0);
 648     n2->AppendInput(graph.zone(), n1);
 649     CHECK_EQ(2, n2->InputCount());
 650     n2->TrimInputCount(1);
 651     CHECK_EQ(1, n2->InputCount());
 652     CHECK_EQ(n0, n2->InputAt(0));
 653     CHECK_EQ(1, n0->UseCount());
 654     CHECK_EQ(0, n1->UseCount());
 655     CHECK_EQ(0, n2->UseCount());
 656   }
 657
 658   {
 659     Node* n0 = graph.NewNode(&dummy_operator);
 660     Node* n1 = graph.NewNode(&dummy_operator);
 661     Node* n2 = graph.NewNode(&dummy_operator);
 662     n2->AppendInput(graph.zone(), n0);
 663     n2->AppendInput(graph.zone(), n1);
 664     CHECK_EQ(2, n2->InputCount());
 665     n2->TrimInputCount(0);
 666     CHECK_EQ(0, n2->InputCount());
 667     CHECK_EQ(0, n0->UseCount());
 668     CHECK_EQ(0, n1->UseCount());
 669     CHECK_EQ(0, n2->UseCount());
 670   }
 671
 672   {
 673     Node* n0 = graph.NewNode(&dummy_operator);
 674     Node* n2 = graph.NewNode(&dummy_operator);
 675     n2->AppendInput(graph.zone(), n0);
 676     n2->AppendInput(graph.zone(), n0);
 677     CHECK_EQ(2, n2->InputCount());
 678     CHECK_EQ(2, n0->UseCount());
 679     n2->TrimInputCount(1);
 680     CHECK_EQ(1, n2->InputCount());
 681     CHECK_EQ(1, n0->UseCount());
 682     CHECK_EQ(0, n2->UseCount());
 683   }
 684
 685   {
 686     Node* n0 = graph.NewNode(&dummy_operator);
 687     Node* n2 = graph.NewNode(&dummy_operator);
 688     n2->AppendInput(graph.zone(), n0);
 689     n2->AppendInput(graph.zone(), n0);
 690     CHECK_EQ(2, n2->InputCount());
 691     CHECK_EQ(2, n0->UseCount());
 692     n2->TrimInputCount(0);
 693     CHECK_EQ(0, n2->InputCount());
 694     CHECK_EQ(0, n0->UseCount());
 695     CHECK_EQ(0, n2->UseCount());
 696   }
 697 }
 698
 699
 700 TEST(TrimInputCountOutOfLine2) {
 701   GraphTester graph;
 702
 703   {
 704     Node* n0 = graph.NewNode(&dummy_operator);
 705     Node* n1 = graph.NewNode(&dummy_operator);
 706     Node* n2 = graph.NewNode(&dummy_operator, n0);
 707     n2->AppendInput(graph.zone(), n1);
 708     CHECK_EQ(2, n2->InputCount());
 709     n2->TrimInputCount(2);
 710     CHECK_EQ(2, n2->InputCount());
 711     CHECK_EQ(n0, n2->InputAt(0));
 712     CHECK_EQ(n1, n2->InputAt(1));
 713     CHECK_EQ(1, n0->UseCount());
 714     CHECK_EQ(1, n1->UseCount());
 715     CHECK_EQ(0, n2->UseCount());
 716   }
 717
 718   {
 719     Node* n0 = graph.NewNode(&dummy_operator);
 720     Node* n1 = graph.NewNode(&dummy_operator);
 721     Node* n2 = graph.NewNode(&dummy_operator, n0);
 722     n2->AppendInput(graph.zone(), n1);
 723     CHECK_EQ(2, n2->InputCount());
 724     n2->TrimInputCount(1);
 725     CHECK_EQ(1, n2->InputCount());
 726     CHECK_EQ(n0, n2->InputAt(0));
 727     CHECK_EQ(1, n0->UseCount());
 728     CHECK_EQ(0, n1->UseCount());
 729     CHECK_EQ(0, n2->UseCount());
 730   }
 731
 732   {
 733     Node* n0 = graph.NewNode(&dummy_operator);
 734     Node* n1 = graph.NewNode(&dummy_operator);
 735     Node* n2 = graph.NewNode(&dummy_operator, n0);
 736     n2->AppendInput(graph.zone(), n1);
 737     CHECK_EQ(2, n2->InputCount());
 738     n2->TrimInputCount(0);
 739     CHECK_EQ(0, n2->InputCount());
 740     CHECK_EQ(0, n0->UseCount());
 741     CHECK_EQ(0, n1->UseCount());
 742     CHECK_EQ(0, n2->UseCount());
 743   }
 744
 745   {
 746     Node* n0 = graph.NewNode(&dummy_operator);
 747     Node* n2 = graph.NewNode(&dummy_operator, n0);
 748     n2->AppendInput(graph.zone(), n0);
 749     CHECK_EQ(2, n2->InputCount());
 750     CHECK_EQ(2, n0->UseCount());
 751     n2->TrimInputCount(1);
 752     CHECK_EQ(1, n2->InputCount());
 753     CHECK_EQ(1, n0->UseCount());
 754     CHECK_EQ(0, n2->UseCount());
 755   }
 756
 757   {
 758     Node* n0 = graph.NewNode(&dummy_operator);
 759     Node* n2 = graph.NewNode(&dummy_operator, n0);
 760     n2->AppendInput(graph.zone(), n0);
 761     CHECK_EQ(2, n2->InputCount());
 762     CHECK_EQ(2, n0->UseCount());
 763     n2->TrimInputCount(0);
 764     CHECK_EQ(0, n2->InputCount());
 765     CHECK_EQ(0, n0->UseCount());
 766     CHECK_EQ(0, n2->UseCount());
 767   }
 768 }
 769
 770
 771 TEST(RemoveAllInputs) {
 772   GraphTester graph;
 773
 774   for (int i = 0; i < 2; i++) {
 775     Node* n0 = graph.NewNode(&dummy_operator);
 776     Node* n1 = graph.NewNode(&dummy_operator, n0);
 777     Node* n2;
 778     if (i == 0) {
 779       n2 = graph.NewNode(&dummy_operator, n0, n1);
 780     } else {
 781       n2 = graph.NewNode(&dummy_operator, n0);
 782       n2->AppendInput(graph.zone(), n1);  // with out-of-line input.
 783     }
 784
 785     n0->RemoveAllInputs();
 786     CHECK_EQ(0, n0->InputCount());
 787
 788     CHECK_EQ(2, n0->UseCount());
 789     n1->RemoveAllInputs();
 790     CHECK_EQ(1, n1->InputCount());
 791     CHECK_EQ(1, n0->UseCount());
 792     CHECK_EQ(NULL, n1->InputAt(0));
 793
 794     CHECK_EQ(1, n1->UseCount());
 795     n2->RemoveAllInputs();
 796     CHECK_EQ(2, n2->InputCount());
 797     CHECK_EQ(0, n0->UseCount());
 798     CHECK_EQ(0, n1->UseCount());
 799     CHECK_EQ(NULL, n2->InputAt(0));
 800     CHECK_EQ(NULL, n2->InputAt(1));
 801   }
 802
 803   {
 804     Node* n0 = graph.NewNode(&dummy_operator);
 805     Node* n1 = graph.NewNode(&dummy_operator, n0);
 806     n1->ReplaceInput(0, n1);  // self-reference.
 807
 808     CHECK_EQ(0, n0->UseCount());
 809     CHECK_EQ(1, n1->UseCount());
 810     n1->RemoveAllInputs();
 811     CHECK_EQ(1, n1->InputCount());
 812     CHECK_EQ(0, n1->UseCount());
 813     CHECK_EQ(NULL, n1->InputAt(0));
 814   }
 815 }