Remove deoptimization by patching the call stack.

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"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 CodeGenerator::CodeGenerator(InstructionSequence* code)
     : code_(code),
       current_block_(NULL),
       current_source_position_(SourcePosition::Invalid()),
       masm_(code->zone()->isolate(), NULL, 0),
       resolver_(this),
       safepoints_(code->zone()),
-      deoptimization_points_(code->zone()),
       deoptimization_states_(code->zone()),
       deoptimization_literals_(code->zone()),
       translations_(code->zone()) {}
 
 
 Handle<Code> CodeGenerator::GenerateCode() {
   CompilationInfo* info = linkage()->info();
 
   // Emit a code line info recording start event.
   PositionsRecorder* recorder = masm()->positions_recorder();
   LOG_CODE_EVENT(isolate(), CodeStartLinePosInfoRecordEvent(recorder));
 
   // Place function entry hook if requested to do so.
   if (linkage()->GetIncomingDescriptor()->IsJSFunctionCall()) {
     ProfileEntryHookStub::MaybeCallEntryHook(masm());
   }
 
   // Architecture-specific, linkage-specific prologue.
   info->set_prologue_offset(masm()->pc_offset());
   AssemblePrologue();
 
   // Assemble all instructions.
   for (InstructionSequence::const_iterator i = code()->begin();
        i != code()->end(); ++i) {
     AssembleInstruction(*i);
   }
 
-  EmitLazyDeoptimizationCallTable();
+  FinishCode(masm());
 
-  FinishCode(masm());
+  // Ensure there is space for lazy deopt.
+  if (!info->IsStub()) {

[Benedikt Meurer, 2014/09/15 08:23:14]

Do we really need/want this check here?

+    int target_offset = masm()->pc_offset() + Deoptimizer::patch_size();
+    while (masm()->pc_offset() < target_offset) {
+      masm()->nop();
+    }
+  }
 
   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;
 }
 
 
-Safepoint::Id CodeGenerator::RecordSafepoint(PointerMap* pointers,
-                                             Safepoint::Kind kind,
-                                             int arguments,
-                                             Safepoint::DeoptMode deopt_mode) {
+void 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::EmitLazyDeoptimizationCallTable() {
-  // ZoneDeque<DeoptimizationPoint*>::iterator iter;
-  int i = 0;
-  for (ZoneDeque<DeoptimizationPoint*>::iterator
-           iter = deoptimization_points_.begin();
-       iter != deoptimization_points_.end(); iter++, i++) {
-    int pc_offset = masm()->pc_offset();
-    AssembleDeoptimizerCall((*iter)->lazy_state_id());
-    safepoints()->SetDeoptimizationPc((*iter)->safepoint(), pc_offset);
-  }
-}
-
-
 void CodeGenerator::PopulateDeoptimizationData(Handle<Code> code_object) {
   CompilationInfo* info = linkage()->info();
   int deopt_count = static_cast<int>(deoptimization_states_.size());
   if (deopt_count == 0) return;
   Handle<DeoptimizationInputData> data =
       DeoptimizationInputData::New(isolate(), deopt_count, TENURED);
 
   Handle<ByteArray> translation_array =
       translations_.CreateByteArray(isolate()->factory());
 
@@ skipping 26 matching lines @@
   data->SetOsrPcOffset(Smi::FromInt(-1));
 
   // Populate deoptimization entries.
   for (int i = 0; i < deopt_count; i++) {
     DeoptimizationState* deoptimization_state = deoptimization_states_[i];
     data->SetAstId(i, deoptimization_state->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));
+    data->SetPc(i, Smi::FromInt(deoptimization_state->pc_offset()));
   }
 
   code_object->set_deoptimization_data(*data);
 }
 
 
 void CodeGenerator::AddSafepointAndDeopt(Instruction* instr) {
   CallDescriptor::Flags flags(MiscField::decode(instr->opcode()));
 
   bool needs_frame_state = (flags & CallDescriptor::kNeedsFrameState);
 
-  Safepoint::Id safepoint_id = RecordSafepoint(
+  RecordSafepoint(
       instr->pointer_map(), Safepoint::kSimple, 0,
       needs_frame_state ? Safepoint::kLazyDeopt : Safepoint::kNoLazyDeopt);
 
+  if (flags & CallDescriptor::kNeedsNopAfterCall) {
+    AddNopForSmiCodeInlining();
+  }
+
   if (needs_frame_state) {
     // If the frame state is present, it starts at argument 1
     // (just after the code address).
     InstructionOperandConverter converter(this, instr);
     // Deoptimization info starts at argument 1
     int frame_state_offset = 1;
     FrameStateDescriptor* descriptor =
         GetFrameStateDescriptor(instr, frame_state_offset);
-    int deopt_state_id =
-        BuildTranslation(instr, frame_state_offset, kIgnoreOutput);
-    int lazy_deopt_state_id = deopt_state_id;
+    int pc_offset = masm()->pc_offset();
+    int deopt_state_id = BuildTranslation(instr, pc_offset, frame_state_offset,
+                                          descriptor->state_combine());
+    // If the pre-call frame state differs from the post-call one, produce the
+    // pre-call frame state, too.
+    // TODO(jarin) We might want to avoid building the pre-call frame state
+    // because it is only used to get locals and arguments (by the debugger and
+    // f.arguments), and those are the same in the pre-call and post-call
+    // states.
     if (descriptor->state_combine() != kIgnoreOutput) {
-      lazy_deopt_state_id = BuildTranslation(instr, frame_state_offset,
-                                             descriptor->state_combine());
+      deopt_state_id =
+          BuildTranslation(instr, -1, frame_state_offset, kIgnoreOutput);
     }
-    deoptimization_points_.push_back(new (zone()) DeoptimizationPoint(
-        deopt_state_id, lazy_deopt_state_id, descriptor, safepoint_id));
 #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.)
     for (int i = 0; i < descriptor->size(); i++) {
       InstructionOperand* op = instr->InputAt(frame_state_offset + 1 + i);
       CHECK(op->IsStackSlot() || op->IsImmediate());
     }
 #endif
-    safepoints()->RecordLazyDeoptimizationIndex(lazy_deopt_state_id);
-  }
-
-  if (flags & CallDescriptor::kNeedsNopAfterCall) {
-    AddNopForSmiCodeInlining();
+    safepoints()->RecordLazyDeoptimizationIndex(deopt_state_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);
@@ skipping 42 matching lines @@
     case kPushOutput:
       DCHECK(instr->OutputCount() == 1);
       AddTranslationForOperand(translation, instr, instr->OutputAt(0));
       break;
     case kIgnoreOutput:
       break;
   }
 }
 
 
-int CodeGenerator::BuildTranslation(Instruction* instr, int frame_state_offset,
+int CodeGenerator::BuildTranslation(Instruction* instr, int pc_offset,
+                                    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()));
+      descriptor->bailout_id(), translation.index(), pc_offset));
 
   return deoptimization_id;
 }
 
 
 void CodeGenerator::AddTranslationForOperand(Translation* translation,
                                              Instruction* instr,
                                              InstructionOperand* op) {
   if (op->IsStackSlot()) {
     translation->StoreStackSlot(op->index());
@@ skipping 73 matching lines @@
 }
 
 
 void CodeGenerator::AddNopForSmiCodeInlining() { UNIMPLEMENTED(); }
 
 #endif  // !V8_TURBOFAN_BACKEND
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8