[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 34 matching lines @@
       safepoints_(code->zone()),
       handlers_(code->zone()),
       deoptimization_exits_(code->zone()),
       deoptimization_states_(code->zone()),
       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) {
+      osr_pc_offset_(-1),
+      deconstruct_frame_when_leaving_(true),
+      deconstruct_frame_between_blocks_(false) {
   for (int i = 0; i < code->InstructionBlockCount(); ++i) {
     new (&labels_[i]) Label;
   }
-  if (code->ContainsCall()) {
-    frame->MarkNeedsFrame();
+}
+
+void CodeGenerator::SetupFrameAccessForBlock(const InstructionBlock* block) {
+  if (block->needs_frame()) {
+    frame_access_state()->SetFrameAccessToFP();
+    frame_access_state()->set_used_frame_slots(
+        frame()->GetTotalFrameSlotCount());
+  } else {
+    frame_access_state()->SetFrameAccessToSP();
+    frame_access_state()->set_used_frame_slots(kElidedFrameSlots);
   }
 }
 
-
 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();
+  // ARM64?
+  // frame()->AlignFrame(16);
+  // SetupStackPointer();
+  //
   if (linkage()->GetIncomingDescriptor()->InitializeRootRegister()) {
     masm()->InitializeRootRegister();

[Mircea Trofin, 2016/03/16 20:20:46]

What's the root register? Seems like something that should happen together with
frame setup.

[danno, 2016/03/16 21:20:56]

Nah, this is unrelated to the frame and should stay. This is the register that
common constants are loaded from, and just needs to be set up once in the
prologue.

[Mircea Trofin, 2016/03/16 21:51:00]

it seems that Simulator::CheckPCSComplianceAndRun cares about this ordering,
though.
Probably best to move it right after AssemblePrologue, at least for now.

   }
 
   // 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);
     }
   }
-
   // 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);
       }
+
+      SetupFrameAccessForBlock(block);
+
       masm()->bind(GetLabel(current_block_));
+      if (block->must_construct_frame()) {
+        DCHECK(frame_access_state()->access_frame_with_fp());
+        AssemblePrologue();
+      }
+      set_deconstruct_frame_between_blocks(false);
+      set_deconstruct_frame_when_leaving(false);
+
       for (int i = block->code_start(); i < block->code_end(); ++i) {
-        AssembleInstruction(code()->InstructionAt(i));
+        Instruction* instr = code()->InstructionAt(i);
+        bool leaves_function =

[danno, 2016/03/16 18:18:11]

This should not be calculated here.  When the blocks are built, or when the
frame elision analysis happens, must_decontruct_frame should be (re)set to false
for the block if the block ends in a deopt or return. That simplifies this logic
a lot, or at least puts the decision in a better place, and I think it makes the
decision much cleaner, you don't have to check every instruction, just the last
one. i.e. somewhere you need:

Instruction* instr = code()->InstructionAt(block->last_instruction_index())
bool leaves_function = instr-> .... as before
if (leaves_function) block->set_must_deconstruct_frame(false);

[Mircea Trofin, 2016/03/16 20:20:46]

That makes sense, indeed. This is also a remnant of the older CL.

+            instr->arch_opcode() == ArchOpcode::kArchRet ||
+            instr->arch_opcode() == ArchOpcode::kArchDeoptimize;
+        if (i == block->last_instruction_index()) {
+          set_deconstruct_frame_when_leaving(block->must_deconstruct_frame());
+          set_deconstruct_frame_between_blocks(!leaves_function &&
+                                               block->must_deconstruct_frame());
+        }
+        AssembleInstruction(instr);
       }
+      AssembleDeconstructFrameBetweenBlocks();
     }
   }
 
   // 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 596 matching lines @@
       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;

[danno, 2016/03/16 21:20:56]

by the way, this will probably end up being 

bool has_frame = frame_access_state->has_frame(), and you will need to
initialize that appropriately based on the prologue based on the logic that is
already there which is dangerously similar to the code above, but in fact the
logic here is probably wrong, it should be _exactly_ the condition which causes
the prologue frame to be generated... thus switching to 
frame_access_state->has_frame() is much "safer", too.

   // 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;
+      has_frame ? (frame_access_state()->used_frame_slots() - pc_slots) : 0;

[danno, 2016/03/16 21:20:56]

If you use frame_access_state->has_frame(), you can keep the logic as it was
before.

   // 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_) {
+    : frame_(gen->frame()),
+      frame_access_state_(gen->frame_access_state()),
+      masm_(gen->masm()),
+      next_(gen->ools_) {
   gen->ools_ = this;
 }
 
 
 OutOfLineCode::~OutOfLineCode() {}
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8