Add deoptimization translations.

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/node-properties.h"
 #include "src/compiler/node-properties-inl.h"
@@ skipping 154 matching lines @@
 
 AstGraphBuilder::Environment::Environment(AstGraphBuilder* builder,
                                           Scope* scope,
                                           Node* control_dependency)
     : StructuredGraphBuilder::Environment(builder, control_dependency),
       parameters_count_(scope->num_parameters() + 1),
       locals_count_(scope->num_stack_slots()),
       parameters_node_(NULL),
       locals_node_(NULL),
       stack_node_(NULL),
-      parameters_dirty_(false),
-      locals_dirty_(false),
-      stack_dirty_(false) {
+      parameters_dirty_(true),
+      locals_dirty_(true),
+      stack_dirty_(true) {
   DCHECK_EQ(scope->num_parameters() + 1, parameters_count());
 
   // Bind the receiver variable.
   Node* receiver = builder->graph()->NewNode(common()->Parameter(0),
                                              builder->graph()->start());
   values()->push_back(receiver);
 
   // Bind all parameter variables. The parameter indices are shifted by 1
   // (receiver is parameter index -1 but environment index 0).
   for (int i = 0; i < scope->num_parameters(); ++i) {
@@ skipping 15 matching lines @@
       locals_count_(copy.locals_count_),
       parameters_node_(copy.parameters_node_),
       locals_node_(copy.locals_node_),
       stack_node_(copy.stack_node_),
       parameters_dirty_(copy.parameters_dirty_),
       locals_dirty_(copy.locals_dirty_),
       stack_dirty_(copy.stack_dirty_) {}
 
 
 Node* AstGraphBuilder::Environment::Checkpoint(BailoutId ast_id) {
-  UNIMPLEMENTED();  // TODO(mstarzinger): Implementation below is incomplete.
   if (parameters_dirty_) {
-    Node** parameters = &values()->front();
-    parameters_node_ = graph()->NewNode(NULL, parameters_count(), parameters);
+    Operator* op = common()->StateValues(parameters_count());
+    if (parameters_count() != 0) {
+      Node** parameters = &values()->front();
+      parameters_node_ = graph()->NewNode(op, parameters_count(), parameters);
+    } else {
+      parameters_node_ = graph()->NewNode(op);
+    }
     parameters_dirty_ = false;
   }
   if (locals_dirty_) {
-    Node** locals = &values()->at(parameters_count_);
-    locals_node_ = graph()->NewNode(NULL, locals_count(), locals);
+    Operator* op = common()->StateValues(locals_count());
+    if (locals_count() != 0) {
+      Node** locals = &values()->at(parameters_count_);
+      locals_node_ = graph()->NewNode(op, locals_count(), locals);
+    } else {
+      locals_node_ = graph()->NewNode(op);
+    }
     locals_dirty_ = false;
   }
-  FrameStateDescriptor descriptor(ast_id);
-  // TODO(jarin): add environment to the node.
-  Operator* op = common()->FrameState(descriptor);
+  if (stack_dirty_) {
+    Operator* op = common()->StateValues(stack_height());
+    if (stack_height() != 0) {
+      Node** stack = &values()->at(parameters_count_ + locals_count_);
+      stack_node_ = graph()->NewNode(op, stack_height(), stack);
+    } else {
+      stack_node_ = graph()->NewNode(op);
+    }
+    stack_dirty_ = false;
+  }
 
-  return graph()->NewNode(op);
+  Operator* op = common()->FrameState(ast_id);
+
+  return graph()->NewNode(op, parameters_node_, locals_node_, stack_node_);
 }
 
 
 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 1717 matching lines @@
 
     StructuredGraphBuilder::Environment* continuation_env =
         environment_internal();
     // Create environment for the deoptimization block, and build the block.
     StructuredGraphBuilder::Environment* deopt_env =
         CopyEnvironment(continuation_env);
     set_environment(deopt_env);
 
     NewNode(common()->LazyDeoptimization());
 
-    FrameStateDescriptor stateDescriptor(ast_id);
-    Node* state_node = NewNode(common()->FrameState(stateDescriptor));
+    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