[crankshaft] Fixing ES6 tail call elimination.

src/crankshaft/mips64/lithium-mips64.cc

Index: src/crankshaft/mips64/lithium-mips64.cc
diff --git a/src/crankshaft/mips64/lithium-mips64.cc b/src/crankshaft/mips64/lithium-mips64.cc
index 29d413391e12b40d5f83c7553584a950a0c69df2..67229c92bd1c4875da047845278f7fcb15e65eb2 100644
--- a/src/crankshaft/mips64/lithium-mips64.cc
+++ b/src/crankshaft/mips64/lithium-mips64.cc
@@ -553,12 +553,7 @@ LInstruction* LChunkBuilder::DefineFixedDouble(
 
 LInstruction* LChunkBuilder::AssignEnvironment(LInstruction* instr) {
   HEnvironment* hydrogen_env = current_block_->last_environment();
-  int argument_index_accumulator = 0;
-  ZoneList<HValue*> objects_to_materialize(0, zone());
-  instr->set_environment(CreateEnvironment(hydrogen_env,
-                                           &argument_index_accumulator,
-                                           &objects_to_materialize));
-  return instr;
+  return LChunkBuilderBase::AssignEnvironment(instr, hydrogen_env);
 }
 
 
@@ -887,15 +882,28 @@ void LChunkBuilder::AddInstruction(LInstruction* instr,
   chunk_->AddInstruction(instr, current_block_);
 
   if (instr->IsCall() || instr->IsPrologue()) {
+    HEnvironment* hydrogen_env = current_block_->last_environment();
     HValue* hydrogen_value_for_lazy_bailout = hydrogen_val;
-    if (hydrogen_val->HasObservableSideEffects()) {
-      HSimulate* sim = HSimulate::cast(hydrogen_val->next());
-      sim->ReplayEnvironment(current_block_->last_environment());
-      hydrogen_value_for_lazy_bailout = sim;
+    DCHECK_NOT_NULL(hydrogen_env);
+    if (instr->IsTailCall()) {
+      hydrogen_env = hydrogen_env->outer();
+      if (hydrogen_env != nullptr &&
+          hydrogen_env->frame_type() == ARGUMENTS_ADAPTOR) {
+        hydrogen_env = hydrogen_env->outer();
+      }
+    } else {
+      if (hydrogen_val->HasObservableSideEffects()) {
+        HSimulate* sim = HSimulate::cast(hydrogen_val->next());
+        sim->ReplayEnvironment(hydrogen_env);
+        hydrogen_value_for_lazy_bailout = sim;
+      }
+    }
+    if (hydrogen_env != nullptr) {
+      LInstruction* bailout = LChunkBuilderBase::AssignEnvironment(
+          new (zone()) LLazyBailout(), hydrogen_env);
+      bailout->set_hydrogen_value(hydrogen_value_for_lazy_bailout);
+      chunk_->AddInstruction(bailout, current_block_);
     }
-    LInstruction* bailout = AssignEnvironment(new(zone()) LLazyBailout());
-    bailout->set_hydrogen_value(hydrogen_value_for_lazy_bailout);
-    chunk_->AddInstruction(bailout, current_block_);
   }
 }
 
@@ -1066,6 +1074,9 @@ LInstruction* LChunkBuilder::DoCallWithDescriptor(
 
   LCallWithDescriptor* result = new(zone()) LCallWithDescriptor(
       descriptor, ops, zone());
+  if (instr->syntactic_tail_call_mode() == TailCallMode::kAllow) {
+    result->MarkAsTailCall();
+  }
   return MarkAsCall(DefineFixed(result, v0), instr);
 }
 
@@ -1074,6 +1085,9 @@ LInstruction* LChunkBuilder::DoInvokeFunction(HInvokeFunction* instr) {
   LOperand* context = UseFixed(instr->context(), cp);
   LOperand* function = UseFixed(instr->function(), a1);
   LInvokeFunction* result = new(zone()) LInvokeFunction(context, function);
+  if (instr->syntactic_tail_call_mode() == TailCallMode::kAllow) {
+    result->MarkAsTailCall();
+  }
   return MarkAsCall(DefineFixed(result, v0), instr, CANNOT_DEOPTIMIZE_EAGERLY);
 }