Model exceptional edges from call nodes in TurboFan.

src/compiler/node-properties.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-properties.h"
 
 #include "src/compiler/common-operator.h"
 #include "src/compiler/operator-properties.h"
 
 namespace v8 {
@@ skipping 134 matching lines @@
 
 
 // static
 void NodeProperties::RemoveNonValueInputs(Node* node) {
   node->TrimInputCount(node->op()->ValueInputCount());
 }
 
 
 // static
 void NodeProperties::ReplaceWithValue(Node* node, Node* value, Node* effect) {
-  DCHECK(node->op()->ControlOutputCount() == 0);
   if (!effect && node->op()->EffectInputCount() > 0) {
     effect = NodeProperties::GetEffectInput(node);
   }
 
-  // Requires distinguishing between value and effect edges.
+  // Requires distinguishing between value, effect and control edges.
   for (Edge edge : node->use_edges()) {
-    if (IsEffectEdge(edge)) {
+    if (IsControlEdge(edge)) {
+      DCHECK_EQ(IrOpcode::kIfSuccess, edge.from()->opcode());
+      Node* control = NodeProperties::GetControlInput(node);
+      edge.from()->ReplaceUses(control);
+      edge.UpdateTo(NULL);
+    } else if (IsEffectEdge(edge)) {
       DCHECK_NOT_NULL(effect);
       edge.UpdateTo(effect);
     } else {
       edge.UpdateTo(value);
     }
   }
 }
 
 
 // static
 Node* NodeProperties::FindProjection(Node* node, size_t projection_index) {
   for (auto use : node->uses()) {
     if (use->opcode() == IrOpcode::kProjection &&
         ProjectionIndexOf(use->op()) == projection_index) {
       return use;
     }
   }
   return nullptr;
 }
 
 
 // static
 void NodeProperties::CollectControlProjections(Node* node, Node** projections,
                                                size_t projection_count) {
 #ifdef DEBUG
-  DCHECK_EQ(static_cast<int>(projection_count), node->UseCount());
+  DCHECK_LE(static_cast<int>(projection_count), node->UseCount());
   std::memset(projections, 0, sizeof(*projections) * projection_count);
 #endif
   size_t if_value_index = 0;
   for (Node* const use : node->uses()) {
     size_t index;
     switch (use->opcode()) {
-      default:
-        UNREACHABLE();
-      // Fall through.
       case IrOpcode::kIfTrue:
         DCHECK_EQ(IrOpcode::kBranch, node->opcode());
         index = 0;
         break;
       case IrOpcode::kIfFalse:
         DCHECK_EQ(IrOpcode::kBranch, node->opcode());
         index = 1;
         break;
+      case IrOpcode::kIfSuccess:
+        DCHECK_EQ(IrOpcode::kCall, node->opcode());
+        index = 0;
+        break;
+      case IrOpcode::kIfException:
+        DCHECK_EQ(IrOpcode::kCall, node->opcode());
+        index = 1;
+        break;
       case IrOpcode::kIfValue:
         DCHECK_EQ(IrOpcode::kSwitch, node->opcode());
         index = if_value_index++;
         break;
       case IrOpcode::kIfDefault:
         DCHECK_EQ(IrOpcode::kSwitch, node->opcode());
         index = projection_count - 1;
         break;
+      default:
+        continue;
     }
     DCHECK_LT(if_value_index, projection_count);
     DCHECK_LT(index, projection_count);
     DCHECK_NULL(projections[index]);
     projections[index] = use;
   }
 #ifdef DEBUG
   for (size_t index = 0; index < projection_count; ++index) {
     DCHECK_NOT_NULL(projections[index]);
   }
@@ skipping 14 matching lines @@
 // static
 bool NodeProperties::IsInputRange(Edge edge, int first, int num) {
   if (num == 0) return false;
   int const index = edge.index();
   return first <= index && index < first + num;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8