Make FrameStates recursive (to be used for inlining).

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, Node* parent) {
   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);
 
-  return graph()->NewNode(op, parameters_node_, locals_node_, stack_node_);
+  return graph()->NewNode(op, parameters_node_, locals_node_, stack_node_,
+                          parent);
 }
 
 
 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 1763 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, jsgraph()->UndefinedConstant());
     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* state_node =
+        environment()->Checkpoint(ast_id, jsgraph()->UndefinedConstant());
     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