[turbofan] Frame elision for code stubs

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/address-map.h"
 #include "src/compiler/code-generator-impl.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/pipeline.h"
@@ skipping 38 matching lines @@
       deoptimization_literals_(code->zone()),
       inlined_function_count_(0),
       translations_(code->zone()),
       last_lazy_deopt_pc_(0),
       jump_tables_(nullptr),
       ools_(nullptr),
       osr_pc_offset_(-1) {
   for (int i = 0; i < code->InstructionBlockCount(); ++i) {
     new (&labels_[i]) Label;
   }
-  if (code->ContainsCall()) {
-    frame->MarkNeedsFrame();
-  }
 }
 
-
 Handle<Code> CodeGenerator::GenerateCode() {
   CompilationInfo* info = this->info();
 
   // Open a frame scope to indicate that there is a frame on the stack.  The
   // MANUAL indicates that the scope shouldn't actually generate code to set up
   // the frame (that is done in AssemblePrologue).
   FrameScope frame_scope(masm(), StackFrame::MANUAL);
 
   // 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();
-  if (linkage()->GetIncomingDescriptor()->InitializeRootRegister()) {
-    masm()->InitializeRootRegister();
-  }
 
   // Define deoptimization literals for all inlined functions.
   DCHECK_EQ(0u, deoptimization_literals_.size());
   for (const CompilationInfo::InlinedFunctionHolder& inlined :
        info->inlined_functions()) {
     if (!inlined.shared_info.is_identical_to(info->shared_info())) {
       DefineDeoptimizationLiteral(inlined.shared_info);
     }
   }
   inlined_function_count_ = deoptimization_literals_.size();
 
   // Define deoptimization literals for all unoptimized code objects of inlined
   // functions. This ensures unoptimized code is kept alive by optimized code.
   for (const CompilationInfo::InlinedFunctionHolder& inlined :
        info->inlined_functions()) {
     if (!inlined.shared_info.is_identical_to(info->shared_info())) {
       DefineDeoptimizationLiteral(inlined.inlined_code_object_root);
     }
   }
-
+  // Finish the Frame
+  frame()->AlignFrame(kFrameAlignmentInBytes);
+  SetupStackPointer();
   // Assemble all non-deferred blocks, followed by deferred ones.
   for (int deferred = 0; deferred < 2; ++deferred) {
     for (const InstructionBlock* block : code()->instruction_blocks()) {
       if (block->IsDeferred() == (deferred == 0)) {
         continue;
       }
       // Align loop headers on 16-byte boundaries.
       if (block->IsLoopHeader()) masm()->Align(16);
       // Ensure lazy deopt doesn't patch handler entry points.
       if (block->IsHandler()) EnsureSpaceForLazyDeopt();
@@ skipping 19 matching lines @@
           buffer = buffer.SubVector(next, buffer.length());
         }
         if (block->loop_header().IsValid()) {
           next =
               SNPrintF(buffer, " (in loop %d)", block->loop_header().ToInt());
           buffer = buffer.SubVector(next, buffer.length());
         }
         SNPrintF(buffer, " --");
         masm()->RecordComment(buffer_start);
       }
+
+      frame_access_state()->MarkHasFrame(block->needs_frame());
+
       masm()->bind(GetLabel(current_block_));
+      if (block->must_construct_frame()) {
+        AssemblePrologue();
+        if (linkage()->GetIncomingDescriptor()->InitializeRootRegister()) {
+          masm()->InitializeRootRegister();
+        }
+      }
+
       for (int i = block->code_start(); i < block->code_end(); ++i) {
-        AssembleInstruction(code()->InstructionAt(i));
+        Instruction* instr = code()->InstructionAt(i);

[danno, 2016/03/22 18:10:09]

This is way more complicated than it needs to be AFAICT. I think you can just
get rid of this code ...

+        if (i == block->last_instruction_index()) {
+          frame_access_state()->set_deconstruct_frame_if_needed(
+              block->must_deconstruct_frame());
+        }
+        AssembleInstruction(instr);
       }
+      AssembleDeconstructFrameIfNeeded();

[danno, 2016/03/22 18:10:09]

And directly here:

if (block->must_deconstruct_frame()) {
  AssembleDeconstructFrame();
}

Then you can get rid of the AssembleDeconstructFrameIfNeeded routine and the
boolean state associated with the decision in the frame state.

[Mircea Trofin, 2016/03/22 19:04:09]

The problem is the instruction being assembled. I may be a conditional branch.
We need to 1) assemble the condition (which may involve accessing the frame), 2)
disassemble the frame, 3) jump. That's why I think we can't avoid
AssembleDeconstructFrameIfNeeded.

     }
   }
 
   // Assemble all out-of-line code.
   if (ools_) {
     masm()->RecordComment("-- Out of line code --");
     for (OutOfLineCode* ool = ools_; ool; ool = ool->next()) {
       masm()->bind(ool->entry());
       ool->Generate();
       if (ool->exit()->is_bound()) masm()->jmp(ool->exit());
@@ skipping 123 matching lines @@
     RootIndexMap map(isolate());
     int root_index = map.Lookup(*object);
     if (root_index != RootIndexMap::kInvalidRootIndex) {
       *index_return = static_cast<Heap::RootListIndex>(root_index);
       return true;
     }
   }
   return false;
 }
 
+void CodeGenerator::AssembleDeconstructFrameIfNeeded() {
+  if (frame_access_state()->deconstruct_frame_if_needed()) {
+    AssembleDeconstructFrame();
+    frame_access_state()->set_deconstruct_frame_if_needed(false);
+  }
+}
+
+bool CodeGenerator::AssembleDeconstructFrameUsingReturnLabel() {
+  bool ret = return_label_.is_bound();
+  if (return_label_.is_bound()) {
+    if (!frame_access_state()->return_block_deconstructs()) {
+      AssembleDeconstructFrameIfNeeded();
+    }
+    masm()->jmp(&return_label_);
+  } else {
+    masm()->bind(&return_label_);
+    if (frame_access_state()->deconstruct_frame_if_needed()) {
+      frame_access_state()->MarkReturnBlockDeconstructs();
+    }
+    AssembleDeconstructFrameIfNeeded();
+  }
+  return ret;
+}
 
 void CodeGenerator::AssembleInstruction(Instruction* instr) {
   AssembleGaps(instr);
   AssembleSourcePosition(instr);
   // Assemble architecture-specific code for the instruction.
   AssembleArchInstruction(instr);
 
   FlagsMode mode = FlagsModeField::decode(instr->opcode());
   FlagsCondition condition = FlagsConditionField::decode(instr->opcode());
   switch (mode) {
@@ skipping 451 matching lines @@
     Instruction* instr, size_t frame_state_offset) {
   int const deoptimization_id = BuildTranslation(
       instr, -1, frame_state_offset, OutputFrameStateCombine::Ignore());
   DeoptimizationExit* const exit =
       new (zone()) DeoptimizationExit(deoptimization_id);
   deoptimization_exits_.push_back(exit);
   return exit;
 }
 
 int CodeGenerator::TailCallFrameStackSlotDelta(int stack_param_delta) {
-  CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
-  int spill_slots = frame()->GetSpillSlotCount();
-  bool has_frame = descriptor->IsJSFunctionCall() || spill_slots > 0;
+  //  CallDescriptor* descriptor = linkage()->GetIncomingDescriptor();
+  //  int spill_slots = frame()->GetSpillSlotCount();
+  // bool has_frame = descriptor->IsJSFunctionCall() || spill_slots > 0;
+  // DCHECK(has_frame == frame_access_state()->frame_enabled());

[danno, 2016/03/22 18:10:09]

I think you can remove this commented-out code.

   // Leave the PC on the stack on platforms that have that as part of their ABI
   int pc_slots = V8_TARGET_ARCH_STORES_RETURN_ADDRESS_ON_STACK ? 1 : 0;
-  int sp_slot_delta =
-      has_frame ? (frame()->GetTotalFrameSlotCount() - pc_slots) : 0;
+  int sp_slot_delta = frame_access_state()->has_frame()
+                          ? (frame()->GetTotalFrameSlotCount() - pc_slots)
+                          : 0;
   // Discard only slots that won't be used by new parameters.
   sp_slot_delta += stack_param_delta;
   return sp_slot_delta;
 }
 
-
 OutOfLineCode::OutOfLineCode(CodeGenerator* gen)
     : frame_(gen->frame()), masm_(gen->masm()), next_(gen->ools_) {
   gen->ools_ = this;
 }
 
 
 OutOfLineCode::~OutOfLineCode() {}
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8