Removal of the deoptimization block from Turbofan

src/compiler/ast-graph-builder.cc

 // 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.
 
 #include "src/compiler/ast-graph-builder.h"
 
 #include "src/compiler.h"
 #include "src/compiler/control-builders.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node-properties.h"
@@ skipping 199 matching lines @@
       }
     }
   }
   if (should_update) {
     Operator* op = common()->StateValues(count);
     (*state_values) = graph()->NewNode(op, count, env_values);
   }
 }
 
 
-Node* AstGraphBuilder::Environment::Checkpoint(BailoutId ast_id) {
+Node* AstGraphBuilder::Environment::Checkpoint(
+    BailoutId ast_id, OutputFrameStateCombine combine) {
   UpdateStateValues(&parameters_node_, 0, parameters_count());
   UpdateStateValues(&locals_node_, parameters_count(), locals_count());
   UpdateStateValues(&stack_node_, parameters_count() + locals_count(),
                     stack_height());
 
-  Operator* op = common()->FrameState(ast_id);
+  Operator* op = common()->FrameState(ast_id, combine);
 
-  return graph()->NewNode(op, parameters_node_, locals_node_, stack_node_);
+  return graph()->NewNode(op, parameters_node_, locals_node_, stack_node_,
+                          GetContext());
 }
 
 
 AstGraphBuilder::AstContext::AstContext(AstGraphBuilder* own,
                                         Expression::Context kind)
     : kind_(kind), owner_(own), outer_(own->ast_context()) {
   owner()->set_ast_context(this);  // Push.
 #ifdef DEBUG
   original_height_ = environment()->stack_height();
 #endif
@@ skipping 838 matching lines @@
       case VARIABLE: {
         Variable* variable = expr->target()->AsVariableProxy()->var();
         old_value = BuildVariableLoad(variable, expr->target()->id());
         break;
       }
       case NAMED_PROPERTY: {
         Node* object = environment()->Top();
         PrintableUnique<Name> name =
             MakeUnique(property->key()->AsLiteral()->AsPropertyName());
         old_value = NewNode(javascript()->LoadNamed(name), object);
-        PrepareFrameState(old_value, property->LoadId(), PUSH_OUTPUT);
+        PrepareFrameState(old_value, property->LoadId(), kPushOutput);
         break;
       }
       case KEYED_PROPERTY: {
         Node* key = environment()->Top();
         Node* object = environment()->Peek(1);
         old_value = NewNode(javascript()->LoadProperty(), object, key);
-        PrepareFrameState(old_value, property->LoadId(), PUSH_OUTPUT);
+        PrepareFrameState(old_value, property->LoadId(), kPushOutput);
         break;
       }
     }
     environment()->Push(old_value);
     VisitForValue(expr->value());
     Node* right = environment()->Pop();
     Node* left = environment()->Pop();
     Node* value = BuildBinaryOp(left, right, expr->binary_op());
-    PrepareFrameState(value, expr->binary_operation()->id(), PUSH_OUTPUT);
+    PrepareFrameState(value, expr->binary_operation()->id(), kPushOutput);
     environment()->Push(value);
   } else {
     VisitForValue(expr->value());
   }
 
   // Store the value.
   Node* value = environment()->Pop();
   switch (assign_type) {
     case VARIABLE: {
       Variable* variable = expr->target()->AsVariableProxy()->var();
@@ skipping 96 matching lines @@
       Node* object = environment()->Top();
       if (property->key()->IsPropertyName()) {
         PrintableUnique<Name> name =
             MakeUnique(property->key()->AsLiteral()->AsPropertyName());
         callee_value = NewNode(javascript()->LoadNamed(name), object);
       } else {
         VisitForValue(property->key());
         Node* key = environment()->Pop();
         callee_value = NewNode(javascript()->LoadProperty(), object, key);
       }
-      PrepareFrameState(callee_value, property->LoadId(), PUSH_OUTPUT);
+      PrepareFrameState(callee_value, property->LoadId(), kPushOutput);
       receiver_value = environment()->Pop();
       // Note that a PROPERTY_CALL requires the receiver to be wrapped into an
       // object for sloppy callees. This could also be modeled explicitly here,
       // thereby obsoleting the need for a flag to the call operator.
       flags = CALL_AS_METHOD;
       break;
     }
     case Call::POSSIBLY_EVAL_CALL:
       possibly_eval = true;
     // Fall through.
@@ skipping 65 matching lines @@
   Handle<String> name = expr->name();
 
   // The callee and the receiver both have to be pushed onto the operand stack
   // before arguments are being evaluated.
   CallFunctionFlags flags = NO_CALL_FUNCTION_FLAGS;
   Node* receiver_value = BuildLoadBuiltinsObject();
   PrintableUnique<String> unique = MakeUnique(name);
   Node* callee_value = NewNode(javascript()->LoadNamed(unique), receiver_value);
   // TODO(jarin): Find/create a bailout id to deoptimize to (crankshaft
   // refuses to optimize functions with jsruntime calls).
-  PrepareFrameState(callee_value, BailoutId::None(), PUSH_OUTPUT);
+  PrepareFrameState(callee_value, BailoutId::None(), kPushOutput);
   environment()->Push(callee_value);
   environment()->Push(receiver_value);
 
   // Evaluate all arguments to the JS runtime call.
   ZoneList<Expression*>* args = expr->arguments();
   VisitForValues(args);
 
   // Create node to perform the JS runtime call.
   Operator* call = javascript()->Call(args->length() + 2, flags);
   Node* value = ProcessArguments(call, args->length() + 2);
@@ skipping 61 matching lines @@
       old_value = BuildVariableLoad(variable, expr->expression()->id());
       stack_depth = 0;
       break;
     }
     case NAMED_PROPERTY: {
       VisitForValue(property->obj());
       Node* object = environment()->Top();
       PrintableUnique<Name> name =
           MakeUnique(property->key()->AsLiteral()->AsPropertyName());
       old_value = NewNode(javascript()->LoadNamed(name), object);
-      PrepareFrameState(old_value, property->LoadId(), PUSH_OUTPUT);
+      PrepareFrameState(old_value, property->LoadId(), kPushOutput);
       stack_depth = 1;
       break;
     }
     case KEYED_PROPERTY: {
       VisitForValue(property->obj());
       VisitForValue(property->key());
       Node* key = environment()->Top();
       Node* object = environment()->Peek(1);
       old_value = NewNode(javascript()->LoadProperty(), object, key);
-      PrepareFrameState(old_value, property->LoadId(), PUSH_OUTPUT);
+      PrepareFrameState(old_value, property->LoadId(), kPushOutput);
       stack_depth = 2;
       break;
     }
   }
 
   // Convert old value into a number.
   old_value = NewNode(javascript()->ToNumber(), old_value);
 
   // Save result for postfix expressions at correct stack depth.
   if (is_postfix) environment()->Poke(stack_depth, old_value);
@@ skipping 330 matching lines @@
                                          ContextualMode contextual_mode) {
   Node* the_hole = jsgraph()->TheHoleConstant();
   VariableMode mode = variable->mode();
   switch (variable->location()) {
     case Variable::UNALLOCATED: {
       // Global var, const, or let variable.
       Node* global = BuildLoadGlobalObject();
       PrintableUnique<Name> name = MakeUnique(variable->name());
       Operator* op = javascript()->LoadNamed(name, contextual_mode);
       Node* node = NewNode(op, global);
-      PrepareFrameState(node, bailout_id, PUSH_OUTPUT);
+      PrepareFrameState(node, bailout_id, kPushOutput);
       return node;
     }
     case Variable::PARAMETER:
     case Variable::LOCAL: {
       // Local var, const, or let variable.
       Node* value = environment()->Lookup(variable);
       if (mode == CONST_LEGACY) {
         // Perform check for uninitialized legacy const variables.
         if (value->op() == the_hole->op()) {
           value = jsgraph()->UndefinedConstant();
@@ skipping 242 matching lines @@
 }
 
 
 void AstGraphBuilder::PrepareFrameState(Node* node, BailoutId ast_id,
                                         OutputFrameStateCombine combine) {
   if (OperatorProperties::HasFrameStateInput(node->op())) {
     int frame_state_index = NodeProperties::GetFrameStateIndex(node);
 
     DCHECK(node->InputAt(frame_state_index)->op()->opcode() == IrOpcode::kDead);
 
-    Node* frame_state_node = environment()->Checkpoint(ast_id);
+    Node* frame_state_node = environment()->Checkpoint(ast_id, combine);
     node->ReplaceInput(frame_state_index, frame_state_node);
   }
-
-  if (OperatorProperties::CanLazilyDeoptimize(node->op())) {
-    // The deopting node should have an outgoing control dependency.
-    DCHECK(environment()->GetControlDependency() == node);
-
-    StructuredGraphBuilder::Environment* continuation_env = environment();
-    // Create environment for the deoptimization block, and build the block.
-    StructuredGraphBuilder::Environment* deopt_env =
-        CopyEnvironment(continuation_env);
-    set_environment(deopt_env);
-
-    if (combine == PUSH_OUTPUT) {
-      environment()->Push(node);
-    }
-
-    NewNode(common()->LazyDeoptimization());
-
-    // TODO(jarin) If ast_id.IsNone(), perhaps we should generate an empty
-    // deopt block and make sure there is no patch entry for this (so
-    // that the deoptimizer dies when trying to deoptimize here).
-    Node* state_node = environment()->Checkpoint(ast_id);
-    Node* deoptimize_node = NewNode(common()->Deoptimize(), state_node);
-    UpdateControlDependencyToLeaveFunction(deoptimize_node);
-
-    // Continue with the original environment.
-    set_environment(continuation_env);
-    NewNode(common()->Continuation());
-  }
 }
 
 }
 }
 }  // namespace v8::internal::compiler