[es6] Properly handle the case when an inlined getter/setter/constructor does a tail call.

src/crankshaft/lithium.cc

 // Copyright 2012 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/crankshaft/lithium.h"
 
 #include "src/ast/scopes.h"
 
 #if V8_TARGET_ARCH_IA32
 #include "src/crankshaft/ia32/lithium-ia32.h"  // NOLINT
@@ skipping 320 matching lines @@
     index = instructions_.length();
     instructions_.Add(instr, zone());
     instructions_.Add(gap, zone());
   }
   if (instr->HasPointerMap()) {
     pointer_maps_.Add(instr->pointer_map(), zone());
     instr->pointer_map()->set_lithium_position(index);
   }
 }
 
-
 LConstantOperand* LChunk::DefineConstantOperand(HConstant* constant) {
   return LConstantOperand::Create(constant->id(), zone());
 }
 
 
 int LChunk::GetParameterStackSlot(int index) const {
   // The receiver is at index 0, the first parameter at index 1, so we
   // shift all parameter indexes down by the number of parameters, and
   // make sure they end up negative so they are distinguishable from
   // spill slots.
@@ skipping 149 matching lines @@
   info()->AbortOptimization(reason);
   status_ = ABORTED;
 }
 
 
 void LChunkBuilderBase::Retry(BailoutReason reason) {
   info()->RetryOptimization(reason);
   status_ = ABORTED;
 }
 
+void LChunkBuilderBase::CreateLazyBailoutForCall(HBasicBlock* current_block,
+                                                 LInstruction* instr,
+                                                 HInstruction* hydrogen_val) {
+  if (!instr->IsCall()) return;
+
+  HEnvironment* hydrogen_env = current_block->last_environment();
+  HValue* hydrogen_value_for_lazy_bailout = hydrogen_val;
+  DCHECK_NOT_NULL(hydrogen_env);
+  if (instr->IsSyntacticTailCall()) {
+    // If it was a syntactic tail call we need to drop the current frame and
+    // all the frames on top of it that are either an arguments adaptor frame
+    // or a tail caller frame.
+    hydrogen_env = hydrogen_env->outer();
+    while (hydrogen_env != nullptr &&
+           (hydrogen_env->frame_type() == ARGUMENTS_ADAPTOR ||
+            hydrogen_env->frame_type() == TAIL_CALLER_FUNCTION)) {
+      hydrogen_env = hydrogen_env->outer();
+    }
+    if (hydrogen_env != nullptr) {
+      if (hydrogen_env->frame_type() == JS_FUNCTION) {

[Igor Sheludko, 2016/05/03 09:38:16]

Note: this is a modification to the old code.

[Jarin, 2016/05/03 14:42:36]

Could you explain why the getters do not need to push here?

Would it makes sense to add an else clause that would DCHECK the expected
frame_types; something like

} else {
  DCHECK(hydrogen_env->frame_type() == GETTER || hydrogen_env->frame_type() ==
SETTER || ....);
}

[Igor Sheludko, 2016/05/06 09:50:03]

Tried to rewrite a comment.

+        // Push return value on top of outer environment.
+        hydrogen_env = hydrogen_env->Copy();
+        hydrogen_env->Push(hydrogen_val);
+      }
+    } else {
+      // Although we don't need this lazy bailout for normal execution
+      // (because when we tail call from the outermost function we should pop
+      // its frame) we still need it when debugger is on.
+      hydrogen_env = current_block->last_environment();
+    }
+  } else {
+    if (hydrogen_val->HasObservableSideEffects()) {
+      HSimulate* sim = HSimulate::cast(hydrogen_val->next());
+      sim->ReplayEnvironment(hydrogen_env);
+      hydrogen_value_for_lazy_bailout = sim;
+    }
+  }
+  LInstruction* bailout = LChunkBuilderBase::AssignEnvironment(
+      new (zone()) LLazyBailout(), hydrogen_env);
+  bailout->set_hydrogen_value(hydrogen_value_for_lazy_bailout);
+  chunk_->AddInstruction(bailout, current_block);
+}
+
 LInstruction* LChunkBuilderBase::AssignEnvironment(LInstruction* instr,
                                                    HEnvironment* hydrogen_env) {
   int argument_index_accumulator = 0;
   ZoneList<HValue*> objects_to_materialize(0, zone());
   DCHECK_NE(TAIL_CALLER_FUNCTION, hydrogen_env->frame_type());
   instr->set_environment(CreateEnvironment(
       hydrogen_env, &argument_index_accumulator, &objects_to_materialize));
   return instr;
 }
 
@@ skipping 153 matching lines @@
 
 LPhase::~LPhase() {
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceLithium(name(), chunk_);
   }
 }
 
 
 }  // namespace internal
 }  // namespace v8