Make FrameStates recursive (to be used for inlining).

src/compiler/code-generator.cc

 // Copyright 2013 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/code-generator.h"
 
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/pipeline.h"
 
@@ skipping 283 matching lines @@
 
 FrameStateDescriptor* CodeGenerator::GetFrameStateDescriptor(
     Instruction* instr, int frame_state_offset) {
   InstructionOperandConverter i(this, instr);
   InstructionSequence::StateId state_id =
       InstructionSequence::StateId::FromInt(i.InputInt32(frame_state_offset));
   return code()->GetFrameStateDescriptor(state_id);
 }
 
 
-int CodeGenerator::BuildTranslation(Instruction* instr, int frame_state_offset,
-                                    OutputFrameStateCombine state_combine) {
-  FrameStateDescriptor* descriptor =
-      GetFrameStateDescriptor(instr, frame_state_offset);
-  frame_state_offset++;
+void CodeGenerator::BuildTranslationForFrameStateDescriptor(
+    FrameStateDescriptor* descriptor, Instruction* instr,
+    Translation* translation, int frame_state_offset,
+    OutputFrameStateCombine state_combine) {
+  // Outer-most state must be added to translation first.
+  if (descriptor->outer_state() != NULL) {
+    BuildTranslationForFrameStateDescriptor(
+        descriptor->outer_state(), instr, translation,
+        frame_state_offset + descriptor->size(),
+        descriptor->outer_state()->state_combine());

[Jarin, 2014/09/02 10:28:38]

I think we will have to ignore the output for the outer guy. Just use
kIgnoreOutput here.

[sigurds, 2014/09/02 10:43:58]

Done.

+  }
 
   int height = descriptor->size() - descriptor->parameters_count();
   switch (state_combine) {
     case kPushOutput:
       height++;
       break;
     case kIgnoreOutput:
       break;
   }
 
-
-  Translation translation(&translations_, 1, 1, zone());
-  translation.BeginJSFrame(descriptor->bailout_id(),
-                           Translation::kSelfLiteralId, height);
+  translation->BeginJSFrame(descriptor->bailout_id(),
+                            Translation::kSelfLiteralId, height);
 
   for (int i = 0; i < descriptor->size(); i++) {
-    AddTranslationForOperand(&translation, instr,
+    AddTranslationForOperand(translation, instr,
                              instr->InputAt(i + frame_state_offset));
   }
 
   switch (state_combine) {
     case kPushOutput:
       DCHECK(instr->OutputCount() == 1);
-      AddTranslationForOperand(&translation, instr, instr->OutputAt(0));
+      AddTranslationForOperand(translation, instr, instr->OutputAt(0));
       break;
     case kIgnoreOutput:
       break;
   }
+}
+
+
+int CodeGenerator::BuildTranslation(Instruction* instr, int frame_state_offset,
+                                    OutputFrameStateCombine state_combine) {
+  FrameStateDescriptor* descriptor =
+      GetFrameStateDescriptor(instr, frame_state_offset);
+  frame_state_offset++;
+
+  int frame_count = descriptor->GetFrameCount();
+  Translation translation(&translations_, frame_count, frame_count, zone());
+  BuildTranslationForFrameStateDescriptor(descriptor, instr, &translation,
+                                          frame_state_offset, state_combine);
 
   int deoptimization_id = static_cast<int>(deoptimization_states_.size());
 
   deoptimization_states_.push_back(new (zone()) DeoptimizationState(
       descriptor->bailout_id(), translation.index()));
 
   return deoptimization_id;
 }
 
 
@@ skipping 78 matching lines @@
 }
 
 
 void CodeGenerator::AddNopForSmiCodeInlining() { UNIMPLEMENTED(); }
 
 #endif  // !V8_TURBOFAN_BACKEND
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8