Fix deoptimization address patching in Turbofan to use safepoints.

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 35 matching lines @@
   AssemblePrologue();
 
   // Assemble all instructions.
   for (InstructionSequence::const_iterator i = code()->begin();
        i != code()->end(); ++i) {
     AssembleInstruction(*i);
   }
 
   FinishCode(masm());
 
+  UpdateSafepointsWithDeoptimizationPc();
   safepoints()->Emit(masm(), frame()->GetSpillSlotCount());
 
   // TODO(titzer): what are the right code flags here?
   Code::Kind kind = Code::STUB;
   if (linkage()->GetIncomingDescriptor()->IsJSFunctionCall()) {
     kind = Code::OPTIMIZED_FUNCTION;
   }
   Handle<Code> result = v8::internal::CodeGenerator::MakeCodeEpilogue(
       masm(), Code::ComputeFlags(kind), info);
   result->set_is_turbofanned(true);
   result->set_stack_slots(frame()->GetSpillSlotCount());
   result->set_safepoint_table_offset(safepoints()->GetCodeOffset());
 
   PopulateDeoptimizationData(result);
 
   // Emit a code line info recording stop event.
   void* line_info = recorder->DetachJITHandlerData();
   LOG_CODE_EVENT(isolate(), CodeEndLinePosInfoRecordEvent(*result, line_info));
 
   return result;
 }
 
 
-void CodeGenerator::RecordSafepoint(PointerMap* pointers, Safepoint::Kind kind,
-                                    int arguments,
-                                    Safepoint::DeoptMode deopt_mode) {
+Safepoint::Id CodeGenerator::RecordSafepoint(PointerMap* pointers,
+                                             Safepoint::Kind kind,
+                                             int arguments,
+                                             Safepoint::DeoptMode deopt_mode) {
   const ZoneList<InstructionOperand*>* operands =
       pointers->GetNormalizedOperands();
   Safepoint safepoint =
       safepoints()->DefineSafepoint(masm(), kind, arguments, deopt_mode);
   for (int i = 0; i < operands->length(); i++) {
     InstructionOperand* pointer = operands->at(i);
     if (pointer->IsStackSlot()) {
       safepoint.DefinePointerSlot(pointer->index(), zone());
     } else if (pointer->IsRegister() && (kind & Safepoint::kWithRegisters)) {
       Register reg = Register::FromAllocationIndex(pointer->index());
       safepoint.DefinePointerRegister(reg, zone());
     }
   }
+  return safepoint.id();
 }
 
 
 void CodeGenerator::AssembleInstruction(Instruction* instr) {
   if (instr->IsBlockStart()) {
     // Bind a label for a block start and handle parallel moves.
     BlockStartInstruction* block_start = BlockStartInstruction::cast(instr);
     current_block_ = block_start->block();
     if (FLAG_code_comments) {
       // TODO(titzer): these code comments are a giant memory leak.
@@ skipping 60 matching lines @@
   for (int i = GapInstruction::FIRST_INNER_POSITION;
        i <= GapInstruction::LAST_INNER_POSITION; i++) {
     GapInstruction::InnerPosition inner_pos =
         static_cast<GapInstruction::InnerPosition>(i);
     ParallelMove* move = instr->GetParallelMove(inner_pos);
     if (move != NULL) resolver()->Resolve(move);
   }
 }
 
 
+void CodeGenerator::UpdateSafepointsWithDeoptimizationPc() {
+  int patch_count = static_cast<int>(lazy_deoptimization_entries_.size());
+  for (int i = 0; i < patch_count; ++i) {
+    LazyDeoptimizationEntry entry = lazy_deoptimization_entries_[i];
+    // TODO(jarin) make sure that there is no code (other than nops)
+    // between the call position and the continuation position.
+    safepoints()->SetDeoptimizationPc(entry.safepoint_id(),
+                                      entry.deoptimization()->pos());
+  }
+}
+
+
 void CodeGenerator::PopulateDeoptimizationData(Handle<Code> code_object) {
   CompilationInfo* info = linkage()->info();
   int deopt_count = code()->GetDeoptimizationEntryCount();
   int patch_count = static_cast<int>(lazy_deoptimization_entries_.size());
   if (patch_count == 0 && deopt_count == 0) return;
-  Handle<DeoptimizationInputData> data = DeoptimizationInputData::New(
-      isolate(), deopt_count, patch_count, TENURED);
+  Handle<DeoptimizationInputData> data =
+      DeoptimizationInputData::New(isolate(), deopt_count, TENURED);
 
   Handle<ByteArray> translation_array =
       translations_.CreateByteArray(isolate()->factory());
 
   data->SetTranslationByteArray(*translation_array);
   data->SetInlinedFunctionCount(Smi::FromInt(0));
   data->SetOptimizationId(Smi::FromInt(info->optimization_id()));
   // TODO(jarin) The following code was copied over from Lithium, not sure
   // whether the scope or the IsOptimizing condition are really needed.
   if (info->IsOptimizing()) {
@@ skipping 23 matching lines @@
   for (int i = 0; i < deopt_count; i++) {
     FrameStateDescriptor* descriptor = code()->GetDeoptimizationEntry(i);
     data->SetAstId(i, descriptor->bailout_id());
     CHECK_NE(NULL, deoptimization_states_[i]);
     data->SetTranslationIndex(
         i, Smi::FromInt(deoptimization_states_[i]->translation_id_));
     data->SetArgumentsStackHeight(i, Smi::FromInt(0));
     data->SetPc(i, Smi::FromInt(-1));
   }
 
-  // Populate the return address patcher entries.
-  for (int i = 0; i < patch_count; ++i) {
-    LazyDeoptimizationEntry entry = lazy_deoptimization_entries_[i];
-    data->SetReturnAddressPc(i, Smi::FromInt(entry.position_after_call()));
-    data->SetPatchedAddressPc(i, Smi::FromInt(entry.deoptimization()->pos()));
-  }
-
   code_object->set_deoptimization_data(*data);
 }
 
 
 void CodeGenerator::AddSafepointAndDeopt(Instruction* instr) {
   CallDescriptor::DeoptimizationSupport deopt =
       static_cast<CallDescriptor::DeoptimizationSupport>(
           MiscField::decode(instr->opcode()));
 
-  if ((deopt & CallDescriptor::kLazyDeoptimization) != 0) {
-    RecordLazyDeoptimizationEntry(instr);
-  }
-
   bool needs_frame_state = (deopt & CallDescriptor::kNeedsFrameState) != 0;
 
-  RecordSafepoint(
+  Safepoint::Id safepoint_id = RecordSafepoint(
       instr->pointer_map(), Safepoint::kSimple, 0,
       needs_frame_state ? Safepoint::kLazyDeopt : Safepoint::kNoLazyDeopt);
 
-  if ((deopt & CallDescriptor::kNeedsFrameState) != 0) {
+  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.
-    BuildTranslation(instr, 2, deoptimization_id);
+    int first_state_value_offset = 2;
+#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);
+      CHECK(op->IsStackSlot() || op->IsImmediate());
+    }
+#endif
+    BuildTranslation(instr, first_state_value_offset, deoptimization_id);
     safepoints()->RecordLazyDeoptimizationIndex(deoptimization_id);
   }
 }
 
 
-void CodeGenerator::RecordLazyDeoptimizationEntry(Instruction* instr) {
+void CodeGenerator::RecordLazyDeoptimizationEntry(Instruction* instr,
+                                                  Safepoint::Id safepoint_id) {
   InstructionOperandConverter i(this, instr);
 
   Label after_call;
   masm()->bind(&after_call);
 
   // The continuation and deoptimization are the last two inputs:
   BasicBlock* cont_block =
       i.InputBlock(static_cast<int>(instr->InputCount()) - 2);
   BasicBlock* deopt_block =
       i.InputBlock(static_cast<int>(instr->InputCount()) - 1);
 
   Label* cont_label = code_->GetLabel(cont_block);
   Label* deopt_label = code_->GetLabel(deopt_block);
 
-  lazy_deoptimization_entries_.push_back(
-      LazyDeoptimizationEntry(after_call.pos(), cont_label, deopt_label));
+  lazy_deoptimization_entries_.push_back(LazyDeoptimizationEntry(
+      after_call.pos(), cont_label, deopt_label, safepoint_id));
 }
 
 
 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;
@@ skipping 99 matching lines @@
 }
 
 
 void CodeGenerator::AddNopForSmiCodeInlining() { UNIMPLEMENTED(); }
 
 #endif  // !V8_TURBOFAN_BACKEND
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8