Unit test of instruction selection for calls with deoptimization.

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 240 matching lines @@
       needs_frame_state ? Safepoint::kLazyDeopt : Safepoint::kNoLazyDeopt);
 
   if ((deopt & CallDescriptor::kLazyDeoptimization) != 0) {
     RecordLazyDeoptimizationEntry(instr, safepoint_id);
   }
 
   if (needs_frame_state) {
     // If the frame state is present, it starts at argument 1
     // (just after the code address).
     InstructionOperandConverter converter(this, instr);
-    // Argument 1 is deoptimization id.
-    int deoptimization_id = converter.ToConstant(instr->InputAt(1)).ToInt32();
-    // The actual frame state values start with argument 2.
-    int first_state_value_offset = 2;
+    // Deoptimization info starts at argument 1
+    int frame_state_offset = 1;
+    int deoptimization_id = BuildTranslation(instr, frame_state_offset);
 #if DEBUG
     // Make sure all the values live in stack slots or they are immediates.
     // (The values should not live in register because registers are clobbered
     // by calls.)
     FrameStateDescriptor* descriptor =
         code()->GetDeoptimizationEntry(deoptimization_id);
     for (int i = 0; i < descriptor->size(); i++) {
-      InstructionOperand* op = instr->InputAt(first_state_value_offset + i);
+      InstructionOperand* op = instr->InputAt(frame_state_offset + 1 + i);
       CHECK(op->IsStackSlot() || op->IsImmediate());
     }
 #endif
-    BuildTranslation(instr, first_state_value_offset, deoptimization_id);
     safepoints()->RecordLazyDeoptimizationIndex(deoptimization_id);
   }
 }
 
 
 void CodeGenerator::RecordLazyDeoptimizationEntry(Instruction* instr,
                                                   Safepoint::Id safepoint_id) {
   InstructionOperandConverter i(this, instr);
 
   Label after_call;
@@ skipping 16 matching lines @@
 int CodeGenerator::DefineDeoptimizationLiteral(Handle<Object> literal) {
   int result = static_cast<int>(deoptimization_literals_.size());
   for (unsigned i = 0; i < deoptimization_literals_.size(); ++i) {
     if (deoptimization_literals_[i].is_identical_to(literal)) return i;
   }
   deoptimization_literals_.push_back(literal);
   return result;
 }
 
 
-void CodeGenerator::BuildTranslation(Instruction* instr,
-                                     int first_argument_index,
-                                     int deoptimization_id) {
+int CodeGenerator::BuildTranslation(Instruction* instr,
+                                    int frame_state_offset) {
+  InstructionOperandConverter i(this, instr);
+  int deoptimization_id = i.InputInt32(frame_state_offset);
+  frame_state_offset++;
+
   // We should build translation only once.
   DCHECK_EQ(NULL, deoptimization_states_[deoptimization_id]);
 
   FrameStateDescriptor* descriptor =
       code()->GetDeoptimizationEntry(deoptimization_id);
   Translation translation(&translations_, 1, 1, zone());
   translation.BeginJSFrame(descriptor->bailout_id(),
                            Translation::kSelfLiteralId,
                            descriptor->size() - descriptor->parameters_count());
 
   for (int i = 0; i < descriptor->size(); i++) {
     AddTranslationForOperand(&translation, instr,
-                             instr->InputAt(i + first_argument_index));
+                             instr->InputAt(i + frame_state_offset));
   }
 
   deoptimization_states_[deoptimization_id] =
       new (zone()) DeoptimizationState(translation.index());
+
+  return deoptimization_id;
 }
 
 
 void CodeGenerator::AddTranslationForOperand(Translation* translation,
                                              Instruction* instr,
                                              InstructionOperand* op) {
   if (op->IsStackSlot()) {
     translation->StoreStackSlot(op->index());
   } else if (op->IsDoubleStackSlot()) {
     translation->StoreDoubleStackSlot(op->index());
@@ skipping 66 matching lines @@
 }
 
 
 void CodeGenerator::AddNopForSmiCodeInlining() { UNIMPLEMENTED(); }
 
 #endif  // !V8_TURBOFAN_BACKEND
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8