Removal of the deoptimization block from Turbofan

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 <deque>
 #include <queue>
 
 #include "src/compiler/scheduler.h"
 
 #include "src/compiler/graph.h"
@@ skipping 77 matching lines @@
 
   void BuildBlocks(Node* node) {
     switch (node->opcode()) {
       case IrOpcode::kLoop:
       case IrOpcode::kMerge:
         BuildBlockForNode(node);
         break;
       case IrOpcode::kBranch:
         BuildBlocksForSuccessors(node, IrOpcode::kIfTrue, IrOpcode::kIfFalse);
         break;
-      case IrOpcode::kCall:
-        if (OperatorProperties::CanLazilyDeoptimize(node->op())) {
-          BuildBlocksForSuccessors(node, IrOpcode::kContinuation,
-                                   IrOpcode::kLazyDeoptimization);
-        }
-        break;
       default:
         break;
     }
   }
 
   void ConnectBlocks(Node* node) {
     switch (node->opcode()) {
       case IrOpcode::kLoop:
       case IrOpcode::kMerge:
         ConnectMerge(node);
         break;
       case IrOpcode::kBranch:
         scheduler_->schedule_root_nodes_.push_back(node);
         ConnectBranch(node);
         break;
-      case IrOpcode::kDeoptimize:
-        scheduler_->schedule_root_nodes_.push_back(node);
-        ConnectDeoptimize(node);
-      case IrOpcode::kCall:
-        if (OperatorProperties::CanLazilyDeoptimize(node->op())) {
-          scheduler_->schedule_root_nodes_.push_back(node);
-          ConnectCall(node);
-        }
-        break;
       case IrOpcode::kReturn:
         scheduler_->schedule_root_nodes_.push_back(node);
         ConnectReturn(node);
         break;
       default:
         break;
     }
   }
 
   void BuildBlockForNode(Node* node) {
     if (schedule_->block(node) == NULL) {
       BasicBlock* block = schedule_->NewBasicBlock();
       Trace("Create block B%d for #%d:%s\n", block->id(), node->id(),
             node->op()->mnemonic());
       FixNode(block, node);
     }
   }
 
   void BuildBlocksForSuccessors(Node* node, IrOpcode::Value a,
                                 IrOpcode::Value b) {
     Node* successors[2];
     CollectSuccessorProjections(node, successors, a, b);
     BuildBlockForNode(successors[0]);
     BuildBlockForNode(successors[1]);
   }
 
   // Collect the branch-related projections from a node, such as IfTrue,
-  // IfFalse, Continuation, and LazyDeoptimization.
+  // IfFalse.
   // TODO(titzer): consider moving this to node.h
   void CollectSuccessorProjections(Node* node, Node** buffer,
                                    IrOpcode::Value true_opcode,
                                    IrOpcode::Value false_opcode) {
     buffer[0] = NULL;
     buffer[1] = NULL;
     for (UseIter i = node->uses().begin(); i != node->uses().end(); ++i) {
       if ((*i)->opcode() == true_opcode) {
         DCHECK_EQ(NULL, buffer[0]);
         buffer[0] = *i;
@@ skipping 33 matching lines @@
   }
 
   void ConnectMerge(Node* merge) {
     BasicBlock* block = schedule_->block(merge);
     DCHECK(block != NULL);
     // For all of the merge's control inputs, add a goto at the end to the
     // merge's basic block.
     for (InputIter j = merge->inputs().begin(); j != merge->inputs().end();
          ++j) {
       BasicBlock* predecessor_block = schedule_->block(*j);
-      if ((*j)->opcode() != IrOpcode::kReturn &&
-          (*j)->opcode() != IrOpcode::kDeoptimize) {
+      if ((*j)->opcode() != IrOpcode::kReturn) {
         TraceConnect(merge, predecessor_block, block);
         schedule_->AddGoto(predecessor_block, block);
       }
     }
   }
 
-  void ConnectDeoptimize(Node* deopt) {
-    Node* deopt_block_node = NodeProperties::GetControlInput(deopt);
-    BasicBlock* deopt_block = schedule_->block(deopt_block_node);
-    TraceConnect(deopt, deopt_block, NULL);
-    schedule_->AddDeoptimize(deopt_block, deopt);
-  }
-
   void ConnectReturn(Node* ret) {
     Node* return_block_node = NodeProperties::GetControlInput(ret);
     BasicBlock* return_block = schedule_->block(return_block_node);
     TraceConnect(ret, return_block, NULL);
     schedule_->AddReturn(return_block, ret);
   }
 
-  void ConnectCall(Node* call) {
-    Node* call_block_node = NodeProperties::GetControlInput(call);
-    BasicBlock* call_block = schedule_->block(call_block_node);
-
-    BasicBlock* successor_blocks[2];
-    CollectSuccessorBlocks(call, successor_blocks, IrOpcode::kContinuation,
-                           IrOpcode::kLazyDeoptimization);
-
-    TraceConnect(call, call_block, successor_blocks[0]);
-    TraceConnect(call, call_block, successor_blocks[1]);
-
-    schedule_->AddCall(call_block, call, successor_blocks[0],
-                       successor_blocks[1]);
-  }
-
   void TraceConnect(Node* node, BasicBlock* block, BasicBlock* succ) {
     DCHECK_NE(NULL, block);
     if (succ == NULL) {
       Trace("Connect #%d:%s, B%d -> end\n", node->id(), node->op()->mnemonic(),
             block->id());
     } else {
       Trace("Connect #%d:%s, B%d -> B%d\n", node->id(), node->op()->mnemonic(),
             block->id(), succ->id());
     }
   }
@@ skipping 892 matching lines @@
 
 #if DEBUG
   if (FLAG_trace_turbo_scheduler) PrintRPO(num_loops, loops, final_order);
   VerifySpecialRPO(num_loops, loops, final_order);
 #endif
   return final_order;
 }
 }
 }
 }  // namespace v8::internal::compiler