Make FrameStates recursive (to be used for inlining).

src/compiler/instruction-selector.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/instruction-selector.h"
 
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/pipeline.h"
@@ skipping 1009 matching lines @@
 }
 
 
 void InstructionSelector::VisitThrow(Node* value) {
   UNIMPLEMENTED();  // TODO(titzer)
 }
 
 
 FrameStateDescriptor* InstructionSelector::GetFrameStateDescriptor(
     Node* state) {
-  DCHECK(state->op()->opcode() == IrOpcode::kFrameState);
+  DCHECK(state->opcode() == IrOpcode::kFrameState);
+  DCHECK_EQ(4, state->InputCount());
   BailoutId ast_id = OpParameter<BailoutId>(state);
-  Node* parameters = state->InputAt(0);
-  Node* locals = state->InputAt(1);
-  Node* stack = state->InputAt(2);
+  int parameters = OpParameter<int>(state->InputAt(0));
+  int locals = OpParameter<int>(state->InputAt(1));
+  int stack = OpParameter<int>(state->InputAt(2));
+  FrameStateDescriptor* parent = NULL;
+  if (state->InputAt(3)->opcode() == IrOpcode::kFrameState) {
+    parent = GetFrameStateDescriptor(state->InputAt(3));
+  }
 
   return new (instruction_zone())
-      FrameStateDescriptor(ast_id, OpParameter<int>(parameters),
-                           OpParameter<int>(locals), OpParameter<int>(stack));
+      FrameStateDescriptor(ast_id, parameters, locals, stack, parent);
 }
 
 
 static InstructionOperand* UseOrImmediate(OperandGenerator* g, Node* input) {
   switch (input->opcode()) {
     case IrOpcode::kInt32Constant:
     case IrOpcode::kNumberConstant:
     case IrOpcode::kFloat64Constant:
     case IrOpcode::kHeapConstant:
       return g->UseImmediate(input);
@@ skipping 19 matching lines @@
   OperandGenerator g(this);
   for (int i = 0; i < descriptor->parameters_count(); i++) {
     inputs->push_back(UseOrImmediate(&g, parameters->InputAt(i)));
   }
   for (int i = 0; i < descriptor->locals_count(); i++) {
     inputs->push_back(UseOrImmediate(&g, locals->InputAt(i)));
   }
   for (int i = 0; i < descriptor->stack_count(); i++) {
     inputs->push_back(UseOrImmediate(&g, stack->InputAt(i)));
   }
+
+  if (descriptor->parent() != NULL) {

[Jarin, 2014/08/29 15:07:07]

Could you recurse first? (So that the outer guys are first in the array.)

[sigurds, 2014/09/01 08:48:18]

Done.

+    AddFrameStateInputs(state->InputAt(3), inputs, descriptor->parent());
+  }
 }
 
 
 void InstructionSelector::VisitDeoptimize(Node* deopt) {
   DCHECK(deopt->op()->opcode() == IrOpcode::kDeoptimize);
   Node* state = deopt->InputAt(0);
   FrameStateDescriptor* descriptor = GetFrameStateDescriptor(state);
   int deoptimization_id = sequence()->AddDeoptimizationEntry(descriptor);
 
   InstructionOperandVector inputs(zone());
@@ skipping 48 matching lines @@
 
 
 void InstructionSelector::VisitCall(Node* call, BasicBlock* continuation,
                                     BasicBlock* deoptimization) {}
 
 #endif  // !V8_TURBOFAN_BACKEND
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8