Detect simple tail calls

src/compiler/scheduler.cc

 // Copyright 2013 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/scheduler.h"
 
 #include <iomanip>
 
 #include "src/base/adapters.h"
 #include "src/bit-vector.h"
@@ skipping 300 matching lines @@
         break;
       case IrOpcode::kLoop:
       case IrOpcode::kMerge:
         BuildBlockForNode(node);
         break;
       case IrOpcode::kBranch:
       case IrOpcode::kSwitch:
         BuildBlocksForSuccessors(node);
         break;
       case IrOpcode::kCall:
-        if (IsExceptionalCall(node)) {
+        if (NodeProperties::IsExceptionalCall(node)) {
           BuildBlocksForSuccessors(node);
         }
         break;
       default:
         break;
     }
   }
 
   void ConnectBlocks(Node* node) {
     switch (node->opcode()) {
@@ skipping 15 matching lines @@
         break;
       case IrOpcode::kReturn:
         scheduler_->UpdatePlacement(node, Scheduler::kFixed);
         ConnectReturn(node);
         break;
       case IrOpcode::kThrow:
         scheduler_->UpdatePlacement(node, Scheduler::kFixed);
         ConnectThrow(node);
         break;
       case IrOpcode::kCall:
-        if (IsExceptionalCall(node)) {
+        if (NodeProperties::IsExceptionalCall(node)) {
           scheduler_->UpdatePlacement(node, Scheduler::kFixed);
           ConnectCall(node);
         }
         break;
       default:
         break;
     }
   }
 
   BasicBlock* BuildBlockForNode(Node* node) {
@@ skipping 144 matching lines @@
     DCHECK_NOT_NULL(block);
     if (succ == NULL) {
       TRACE("Connect #%d:%s, id:%d -> end\n", node->id(),
             node->op()->mnemonic(), block->id().ToInt());
     } else {
       TRACE("Connect #%d:%s, id:%d -> id:%d\n", node->id(),
             node->op()->mnemonic(), block->id().ToInt(), succ->id().ToInt());
     }
   }
 
-  bool IsExceptionalCall(Node* node) {
-    for (Node* const use : node->uses()) {
-      if (use->opcode() == IrOpcode::kIfException) return true;
-    }
-    return false;
-  }
-
   bool IsFinalMerge(Node* node) {
     return (node->opcode() == IrOpcode::kMerge &&
             node == scheduler_->graph_->end()->InputAt(0));
   }
 
   bool IsSingleEntrySingleExitRegion(Node* entry, Node* exit) const {
     size_t entry_class = scheduler_->equivalence_->ClassOf(entry);
     size_t exit_class = scheduler_->equivalence_->ClassOf(exit);
     return entry != exit && entry_class == exit_class;
   }
@@ skipping 1152 matching lines @@
   for (Node* const node : *nodes) {
     schedule_->SetBlockForNode(to, node);
     scheduled_nodes_[to->id().ToSize()].push_back(node);
   }
   nodes->clear();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8