Removal of the deoptimization block from Turbofan

src/compiler/ast-graph-builder.h

 // Copyright 2014 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_AST_GRAPH_BUILDER_H_
 #define V8_COMPILER_AST_GRAPH_BUILDER_H_
 
 #include "src/v8.h"
 
 #include "src/ast.h"
@@ skipping 154 matching lines @@
   void VisitNot(UnaryOperation* expr);
 
   // Dispatched from VisitBinaryOperation.
   void VisitComma(BinaryOperation* expr);
   void VisitLogicalExpression(BinaryOperation* expr);
   void VisitArithmeticExpression(BinaryOperation* expr);
 
   // Dispatched from VisitForInStatement.
   void VisitForInAssignment(Expression* expr, Node* value);
 
-  // Flag that describes how to combine the current environment with
-  // the output of a node to obtain a framestate for lazy bailout.
-  enum OutputFrameStateCombine {
-    PUSH_OUTPUT,   // Push the output on the expression stack.
-    IGNORE_OUTPUT  // Use the frame state as-is.
-  };
-
   // Builds deoptimization for a given node.
   void PrepareFrameState(Node* node, BailoutId ast_id,
-                         OutputFrameStateCombine combine = IGNORE_OUTPUT);
+                         OutputFrameStateCombine combine = kIgnoreOutput);
 
   OutputFrameStateCombine StateCombineFromAstContext();
 
   DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
   DISALLOW_COPY_AND_ASSIGN(AstGraphBuilder);
 };
 
 
 // The abstract execution environment for generated code consists of
 // parameter variables, local variables and the operand stack. The
@@ skipping 63 matching lines @@
     int index = static_cast<int>(values()->size()) - depth - 1;
     return values()->at(index);
   }
   void Drop(int depth) {
     DCHECK(depth >= 0 && depth <= stack_height());
     values()->erase(values()->end() - depth, values()->end());
   }
 
   // Preserve a checkpoint of the environment for the IR graph. Any
   // further mutation of the environment will not affect checkpoints.
-  Node* Checkpoint(BailoutId ast_id);
+  Node* Checkpoint(BailoutId ast_id, OutputFrameStateCombine combine);
 
  private:
   void UpdateStateValues(Node** state_values, int offset, int count);
 
   int parameters_count_;
   int locals_count_;
   Node* parameters_node_;
   Node* locals_node_;
   Node* stack_node_;
 };
 
 
 // Each expression in the AST is evaluated in a specific context. This context
 // decides how the evaluation result is passed up the visitor.
 class AstGraphBuilder::AstContext BASE_EMBEDDED {
  public:
   bool IsEffect() const { return kind_ == Expression::kEffect; }
   bool IsValue() const { return kind_ == Expression::kValue; }
   bool IsTest() const { return kind_ == Expression::kTest; }
 
   // Determines how to combine the frame state with the value
   // that is about to be plugged into this AstContext.
-  AstGraphBuilder::OutputFrameStateCombine GetStateCombine() {
-    return IsEffect() ? IGNORE_OUTPUT : PUSH_OUTPUT;
+  OutputFrameStateCombine GetStateCombine() {
+    return IsEffect() ? kIgnoreOutput : kPushOutput;
   }
 
   // Plug a node into this expression context.  Call this function in tail
   // position in the Visit functions for expressions.
   virtual void ProduceValue(Node* value) = 0;
 
   // Unplugs a node from this expression context.  Call this to retrieve the
   // result of another Visit function that already plugged the context.
   virtual Node* ConsumeValue() = 0;
 
@@ skipping 119 matching lines @@
 };
 
 Scope* AstGraphBuilder::current_scope() const {
   return execution_context_->scope();
 }
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_COMPILER_AST_GRAPH_BUILDER_H_