Model exceptional edges from call nodes in TurboFan.

test/unittests/compiler/schedule-unittest.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/compiler/node.h"
 #include "src/compiler/schedule.h"
 #include "test/unittests/test-utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using testing::ElementsAre;
@@ skipping 55 matching lines @@
   EXPECT_EQ(&b0, BasicBlock::GetCommonDominator(&b1, &b3));
   EXPECT_EQ(&b0, BasicBlock::GetCommonDominator(&b3, &b1));
 }
 
 
 typedef TestWithZone ScheduleTest;
 
 
 namespace {
 
+const Operator kCallOperator(IrOpcode::kCall, Operator::kNoProperties,
+                             "MockCall", 0, 0, 0, 0, 0, 0);
 const Operator kBranchOperator(IrOpcode::kBranch, Operator::kNoProperties,
-                               "Branch", 0, 0, 0, 0, 0, 0);
+                               "MockBranch", 0, 0, 0, 0, 0, 0);
 const Operator kDummyOperator(IrOpcode::kParameter, Operator::kNoProperties,
                               "Dummy", 0, 0, 0, 0, 0, 0);
 
 }  // namespace
 
 
 TEST_F(ScheduleTest, Constructor) {
   Schedule schedule(zone());
   EXPECT_NE(nullptr, schedule.start());
   EXPECT_EQ(schedule.start(),
@@ skipping 40 matching lines @@
   EXPECT_EQ(1u, block->PredecessorCount());
   EXPECT_EQ(0u, block->SuccessorCount());
   EXPECT_EQ(start, block->PredecessorAt(0));
   EXPECT_THAT(block->predecessors(), ElementsAre(start));
 
   EXPECT_EQ(0u, end->PredecessorCount());
   EXPECT_EQ(0u, end->SuccessorCount());
 }
 
 
+TEST_F(ScheduleTest, AddCall) {
+  Schedule schedule(zone());
+  BasicBlock* start = schedule.start();
+
+  Node* call = Node::New(zone(), 0, &kCallOperator, 0, nullptr, false);
+  BasicBlock* sblock = schedule.NewBasicBlock();
+  BasicBlock* eblock = schedule.NewBasicBlock();
+  schedule.AddCall(start, call, sblock, eblock);
+
+  EXPECT_EQ(start, schedule.block(call));
+
+  EXPECT_EQ(0u, start->PredecessorCount());
+  EXPECT_EQ(2u, start->SuccessorCount());
+  EXPECT_EQ(sblock, start->SuccessorAt(0));
+  EXPECT_EQ(eblock, start->SuccessorAt(1));
+  EXPECT_THAT(start->successors(), ElementsAre(sblock, eblock));
+
+  EXPECT_EQ(1u, sblock->PredecessorCount());
+  EXPECT_EQ(0u, sblock->SuccessorCount());
+  EXPECT_EQ(start, sblock->PredecessorAt(0));
+  EXPECT_THAT(sblock->predecessors(), ElementsAre(start));
+
+  EXPECT_EQ(1u, eblock->PredecessorCount());
+  EXPECT_EQ(0u, eblock->SuccessorCount());
+  EXPECT_EQ(start, eblock->PredecessorAt(0));
+  EXPECT_THAT(eblock->predecessors(), ElementsAre(start));
+}
+
+
 TEST_F(ScheduleTest, AddBranch) {
   Schedule schedule(zone());
   BasicBlock* start = schedule.start();
 
   Node* branch = Node::New(zone(), 0, &kBranchOperator, 0, nullptr, false);
   BasicBlock* tblock = schedule.NewBasicBlock();
   BasicBlock* fblock = schedule.NewBasicBlock();
   schedule.AddBranch(start, branch, tblock, fblock);
 
   EXPECT_EQ(start, schedule.block(branch));
@@ skipping 61 matching lines @@
 
   EXPECT_EQ(1u, end->PredecessorCount());
   EXPECT_EQ(0u, end->SuccessorCount());
   EXPECT_EQ(mblock, end->PredecessorAt(0));
   EXPECT_THAT(end->predecessors(), ElementsAre(mblock));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8