[crankshaft] Support ES6 tail call elimination.

src/crankshaft/hydrogen.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/crankshaft/hydrogen.h"
 
 #include <sstream>
 
 #include "src/allocation-site-scopes.h"
 #include "src/ast/ast-numbering.h"
@@ skipping 7977 matching lines @@
   }
 }
 
 HInstruction* HOptimizedGraphBuilder::NewCallFunction(
     HValue* function, int argument_count, ConvertReceiverMode convert_mode,
     TailCallMode tail_call_mode) {
   HValue* arity = Add<HConstant>(argument_count - 1);
 
   HValue* op_vals[] = {context(), function, arity};
 
-  // TODO(ishell): use tail_call_mode here.
-  Callable callable = CodeFactory::Call(isolate(), convert_mode);
+  Callable callable =
+      CodeFactory::Call(isolate(), convert_mode, tail_call_mode);
   HConstant* stub = Add<HConstant>(callable.code());
 
   return New<HCallWithDescriptor>(stub, argument_count, callable.descriptor(),
                                   Vector<HValue*>(op_vals, arraysize(op_vals)));
 }
 
 HInstruction* HOptimizedGraphBuilder::NewCallFunctionViaIC(
     HValue* function, int argument_count, ConvertReceiverMode convert_mode,
     TailCallMode tail_call_mode, FeedbackVectorSlot slot) {
   int arity = argument_count - 1;
   Handle<TypeFeedbackVector> vector(current_feedback_vector(), isolate());
   HValue* index_val = Add<HConstant>(vector->GetIndex(slot));
   HValue* vector_val = Add<HConstant>(vector);
 
   HValue* op_vals[] = {context(), function, index_val, vector_val};
 
-  // TODO(ishell): use tail_call_mode here.
   Callable callable = CodeFactory::CallICInOptimizedCode(
-      isolate(), arity, ConvertReceiverMode::kNullOrUndefined);
+      isolate(), arity, ConvertReceiverMode::kNullOrUndefined, tail_call_mode);
   HConstant* stub = Add<HConstant>(callable.code());
 
   return New<HCallWithDescriptor>(stub, argument_count, callable.descriptor(),
                                   Vector<HValue*>(op_vals, arraysize(op_vals)));
 }
 
 HInstruction* HOptimizedGraphBuilder::NewCallConstantFunction(
     Handle<JSFunction> function, int argument_count,
     TailCallMode tail_call_mode) {
-  // TODO(ishell): use tail_call_mode here.
   HValue* target = Add<HConstant>(function);
-  return New<HInvokeFunction>(target, function, argument_count);
+  return New<HInvokeFunction>(target, function, argument_count, tail_call_mode);
 }
 
 
 class FunctionSorter {
  public:
   explicit FunctionSorter(int index = 0, int ticks = 0, int size = 0)
       : index_(index), ticks_(ticks), size_(size) {}
 
   int index() const { return index_; }
   int ticks() const { return ticks_; }
@@ skipping 1329 matching lines @@
     }
 
     if (TryInlineIndirectCall(known_function, expr, args_count_no_receiver)) {
       return;
     }
   }
 
   TailCallMode syntactic_tail_call_mode = expr->tail_call_mode();
   TailCallMode tail_call_mode =
       function_state()->ComputeTailCallMode(syntactic_tail_call_mode);
-  USE(tail_call_mode);
 
-  // TODO(ishell): use tail_call_mode here.
   PushArgumentsFromEnvironment(arguments_count);
-  HInvokeFunction* call =
-      New<HInvokeFunction>(function, known_function, arguments_count);
+  HInvokeFunction* call = New<HInvokeFunction>(function, known_function,
+                                               arguments_count, tail_call_mode);
   Drop(1);  // Function
   ast_context()->ReturnInstruction(call, expr->id());
 }
 
 
 bool HOptimizedGraphBuilder::TryIndirectCall(Call* expr) {
   DCHECK(expr->expression()->IsProperty());
 
   if (!expr->IsMonomorphic()) {
     return false;
@@ skipping 34 matching lines @@
   HValue* function = Pop();  // f
   Drop(1);  // apply
 
   Handle<Map> function_map = expr->GetReceiverTypes()->first();
   HValue* checked_function = AddCheckMap(function, function_map);
 
   if (function_state()->outer() == NULL) {
     TailCallMode syntactic_tail_call_mode = expr->tail_call_mode();
     TailCallMode tail_call_mode =
         function_state()->ComputeTailCallMode(syntactic_tail_call_mode);
-    USE(tail_call_mode);
 
-    // TODO(ishell): use tail_call_mode here.
     HInstruction* elements = Add<HArgumentsElements>(false);
     HInstruction* length = Add<HArgumentsLength>(elements);
     HValue* wrapped_receiver = BuildWrapReceiver(receiver, checked_function);
-    HInstruction* result = New<HApplyArguments>(function,
-                                                wrapped_receiver,
-                                                length,
-                                                elements);
+    HInstruction* result = New<HApplyArguments>(
+        function, wrapped_receiver, length, elements, tail_call_mode);
     ast_context()->ReturnInstruction(result, expr->id());
   } else {
     // We are inside inlined function and we know exactly what is inside
     // arguments object. But we need to be able to materialize at deopt.
     DCHECK_EQ(environment()->arguments_environment()->parameter_count(),
               function_state()->entry()->arguments_object()->arguments_count());
     HArgumentsObject* args = function_state()->entry()->arguments_object();
     const ZoneList<HValue*>* arguments_values = args->arguments_values();
     int arguments_count = arguments_values->length();
     Push(function);
@@ skipping 247 matching lines @@
   if (args->length() != 2) return false;
   VariableProxy* arg_two = args->at(1)->AsVariableProxy();
   if (arg_two == NULL || !arg_two->var()->IsStackAllocated()) return false;
   HValue* arg_two_value = LookupAndMakeLive(arg_two->var());
   if (!arg_two_value->CheckFlag(HValue::kIsArguments)) return false;
   return true;
 }
 
 
 void HOptimizedGraphBuilder::VisitCall(Call* expr) {
-  if (expr->tail_call_mode() == TailCallMode::kAllow) {
-    return Bailout(kTailCall);
-  }
   DCHECK(!HasStackOverflow());
   DCHECK(current_block() != NULL);
   DCHECK(current_block()->HasPredecessor());
   if (!top_info()->is_tracking_positions()) SetSourcePosition(expr->position());
   Expression* callee = expr->expression();
   int argument_count = expr->arguments()->length() + 1;  // Plus receiver.
   HInstruction* call = NULL;
 
   TailCallMode syntactic_tail_call_mode = expr->tail_call_mode();
   TailCallMode tail_call_mode =
@@ skipping 3776 matching lines @@
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8