Removal of the deoptimization block from Turbofan

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()),
-      lazy_deoptimization_entries_(code->zone()),
+      deoptimization_points_(code->zone()),
       deoptimization_states_(code->zone()),
       deoptimization_literals_(code->zone()),
-      translations_(code->zone()) {
-  deoptimization_states_.resize(code->GetDeoptimizationEntryCount(), NULL);
-}
+      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());
 
-  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);
@@ skipping 101 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::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 = code()->GetDeoptimizationEntryCount();
-  int patch_count = static_cast<int>(lazy_deoptimization_entries_.size());
-  if (patch_count == 0 && deopt_count == 0) return;
+  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());
 
   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
@@ skipping 16 matching lines @@
     data->SetLiteralArray(*literals);
   }
 
   // No OSR in Turbofan yet...
   BailoutId osr_ast_id = BailoutId::None();
   data->SetOsrAstId(Smi::FromInt(osr_ast_id.ToInt()));
   data->SetOsrPcOffset(Smi::FromInt(-1));
 
   // Populate deoptimization entries.
   for (int i = 0; i < deopt_count; i++) {
-    FrameStateDescriptor* descriptor = code()->GetDeoptimizationEntry(i);
-    data->SetAstId(i, descriptor->bailout_id());
+    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_));
+        i, Smi::FromInt(deoptimization_states_[i]->translation_id()));
     data->SetArgumentsStackHeight(i, Smi::FromInt(0));
     data->SetPc(i, Smi::FromInt(-1));
   }
 
   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(
       instr->pointer_map(), Safepoint::kSimple, 0,
       needs_frame_state ? Safepoint::kLazyDeopt : Safepoint::kNoLazyDeopt);
 
-  if (flags & CallDescriptor::kLazyDeoptimization) {
-    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);
     // Deoptimization info starts at argument 1
     int frame_state_offset = 1;
-    int deoptimization_id = BuildTranslation(instr, frame_state_offset);
+    FrameStateDescriptor* descriptor =
+        GetFrameStateDescriptor(instr, frame_state_offset);
+    int deopt_state_id =
+        BuildTranslation(instr, frame_state_offset, IGNORE_OUTPUT);
+    int lazy_deopt_state_id = deopt_state_id;
+    if (descriptor->state_combine() != IGNORE_OUTPUT) {
+      lazy_deopt_state_id = BuildTranslation(instr, frame_state_offset,
+                                             descriptor->state_combine());
+    }
+    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.)
-    FrameStateDescriptor* descriptor =
-        code()->GetDeoptimizationEntry(deoptimization_id);
     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(deoptimization_id);
+    safepoints()->RecordLazyDeoptimizationIndex(lazy_deopt_state_id);
   }
 
   if (flags & CallDescriptor::kNeedsNopAfterCall) {
     AddNopForSmiCodeInlining();
   }
 }
 
 
-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, 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;
 }
 
 
-int CodeGenerator::BuildTranslation(Instruction* instr,
-                                    int frame_state_offset) {
+FrameStateDescriptor* CodeGenerator::GetFrameStateDescriptor(
+    Instruction* instr, int frame_state_offset) {
   InstructionOperandConverter i(this, instr);
-  int deoptimization_id = i.InputInt32(frame_state_offset);
+  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++;
 
-  // We should build translation only once.
-  DCHECK_EQ(NULL, deoptimization_states_[deoptimization_id]);
+  int height = descriptor->size() - descriptor->parameters_count();
+  switch (state_combine) {
+    case PUSH_OUTPUT:
+      height++;
+      break;
+    case IGNORE_OUTPUT:
+      break;
+  }
 
-  FrameStateDescriptor* descriptor =
-      code()->GetDeoptimizationEntry(deoptimization_id);
+
   Translation translation(&translations_, 1, 1, zone());
   translation.BeginJSFrame(descriptor->bailout_id(),
-                           Translation::kSelfLiteralId,
-                           descriptor->size() - descriptor->parameters_count());
+                           Translation::kSelfLiteralId, height);
 
   for (int i = 0; i < descriptor->size(); i++) {
     AddTranslationForOperand(&translation, instr,
                              instr->InputAt(i + frame_state_offset));
   }
 
-  deoptimization_states_[deoptimization_id] =
-      new (zone()) DeoptimizationState(translation.index());
+  switch (state_combine) {
+    case PUSH_OUTPUT:
+      DCHECK(instr->OutputCount() == 1);
+      AddTranslationForOperand(&translation, instr, instr->OutputAt(0));
+      break;
+    case IGNORE_OUTPUT:
+      break;
+  }
+
+  int deoptimization_id = static_cast<int>(deoptimization_states_.size());
+
+  deoptimization_states_.push_back(new (zone()) DeoptimizationState(
+      descriptor->bailout_id(), translation.index()));
 
   return deoptimization_id;
 }
 
 
 void CodeGenerator::AddTranslationForOperand(Translation* translation,
                                              Instruction* instr,
                                              InstructionOperand* op) {
   if (op->IsStackSlot()) {
     translation->StoreStackSlot(op->index());
@@ skipping 68 matching lines @@
 }
 
 
 void CodeGenerator::AddNopForSmiCodeInlining() { UNIMPLEMENTED(); }
 
 #endif  // !V8_TURBOFAN_BACKEND
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8