Removal of the deoptimization block from Turbofan

src/compiler/schedule.h

 // 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.
 
 #ifndef V8_COMPILER_SCHEDULE_H_
 #define V8_COMPILER_SCHEDULE_H_
 
 #include <vector>
 
 #include "src/v8.h"
@@ skipping 12 matching lines @@
 
 class BasicBlock;
 class Graph;
 class ConstructScheduleData;
 class CodeGenerator;  // Because of a namespace bug in clang.
 
 class BasicBlockData {
  public:
   // Possible control nodes that can end a block.
   enum Control {
-    kNone,       // Control not initialized yet.
-    kGoto,       // Goto a single successor block.
-    kBranch,     // Branch if true to first successor, otherwise second.
-    kReturn,     // Return a value from this method.
-    kThrow,      // Throw an exception.
-    kCall,       // Call to a possibly deoptimizing or throwing function.
-    kDeoptimize  // Deoptimize.
+    kNone,    // Control not initialized yet.
+    kGoto,    // Goto a single successor block.
+    kBranch,  // Branch if true to first successor, otherwise second.
+    kReturn,  // Return a value from this method.
+    kThrow    // Throw an exception.
   };
 
   int32_t rpo_number_;       // special RPO number of the block.
   BasicBlock* dominator_;    // Immediate dominator of the block.
   BasicBlock* loop_header_;  // Pointer to dominating loop header basic block,
                              // NULL if none. For loop headers, this points to
                              // enclosing loop header.
   int32_t loop_depth_;       // loop nesting, 0 is top-level
   int32_t loop_end_;         // end of the loop, if this block is a loop header.
   int32_t code_start_;       // start index of arch-specific code.
@@ skipping 177 matching lines @@
     SetBlockForNode(block, node);
   }
 
   // BasicBlock building: add a goto to the end of {block}.
   void AddGoto(BasicBlock* block, BasicBlock* succ) {
     DCHECK(block->control_ == BasicBlock::kNone);
     block->control_ = BasicBlock::kGoto;
     AddSuccessor(block, succ);
   }
 
-  // BasicBlock building: add a (branching) call at the end of {block}.
-  void AddCall(BasicBlock* block, Node* call, BasicBlock* cont_block,
-               BasicBlock* deopt_block) {
-    DCHECK(block->control_ == BasicBlock::kNone);
-    DCHECK(call->opcode() == IrOpcode::kCall);
-    block->control_ = BasicBlock::kCall;
-    // Insert the deopt block first so that the RPO order builder picks
-    // it first (and thus it ends up late in the RPO order).
-    AddSuccessor(block, deopt_block);
-    AddSuccessor(block, cont_block);
-    SetControlInput(block, call);
-    SetBlockForNode(block, call);
-  }
-
   // BasicBlock building: add a branch at the end of {block}.
   void AddBranch(BasicBlock* block, Node* branch, BasicBlock* tblock,
                  BasicBlock* fblock) {
     DCHECK(block->control_ == BasicBlock::kNone);
     DCHECK(branch->opcode() == IrOpcode::kBranch);
     block->control_ = BasicBlock::kBranch;
     AddSuccessor(block, tblock);
     AddSuccessor(block, fblock);
     SetControlInput(block, branch);
     if (branch->opcode() == IrOpcode::kBranch) {
@@ skipping 15 matching lines @@
   }
 
   // BasicBlock building: add a throw at the end of {block}.
   void AddThrow(BasicBlock* block, Node* input) {
     DCHECK(block->control_ == BasicBlock::kNone);
     block->control_ = BasicBlock::kThrow;
     SetControlInput(block, input);
     if (block != end()) AddSuccessor(block, end());
   }
 
-  // BasicBlock building: add a deopt at the end of {block}.
-  void AddDeoptimize(BasicBlock* block, Node* state) {
-    DCHECK(block->control_ == BasicBlock::kNone);
-    block->control_ = BasicBlock::kDeoptimize;
-    SetControlInput(block, state);
-    block->deferred_ = true;  // By default, consider deopts the slow path.
-    if (block != end()) AddSuccessor(block, end());
-  }
-
   friend class Scheduler;
   friend class CodeGenerator;
 
   void AddSuccessor(BasicBlock* block, BasicBlock* succ) {
     succ->AppendInput(zone_, block);
   }
 
   BasicBlockVector* rpo_order() { return &rpo_order_; }
 
  private:
@@ skipping 17 matching lines @@
   BasicBlockVector nodeid_to_block_;      // Map from node to containing block.
   BasicBlockVector rpo_order_;            // Reverse-post-order block list.
 };
 
 OStream& operator<<(OStream& os, const Schedule& s);
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_SCHEDULE_H_