Revert of [crankshaft] Fixing 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 5495 matching lines @@
   // Use the fast case closure allocation code that allocates in new
   // space for nested functions that don't need literals cloning.
   HConstant* shared_info_value = Add<HConstant>(shared_info);
   HInstruction* instr;
   if (!expr->pretenure() && shared_info->num_literals() == 0) {
     FastNewClosureStub stub(isolate(), shared_info->language_mode(),
                             shared_info->kind());
     FastNewClosureDescriptor descriptor(isolate());
     HValue* values[] = {context(), shared_info_value};
     HConstant* stub_value = Add<HConstant>(stub.GetCode());
-    instr = New<HCallWithDescriptor>(
-        stub_value, 0, descriptor, Vector<HValue*>(values, arraysize(values)));
+    instr = New<HCallWithDescriptor>(stub_value, 0, descriptor,
+                                     Vector<HValue*>(values, arraysize(values)),
+                                     NORMAL_CALL);
   } else {
     Add<HPushArguments>(shared_info_value);
     Runtime::FunctionId function_id =
         expr->pretenure() ? Runtime::kNewClosure_Tenured : Runtime::kNewClosure;
     instr = New<HCallRuntime>(Runtime::FunctionForId(function_id), 1);
   }
   return ast_context()->ReturnInstruction(instr, expr->id());
 }
 
 
@@ skipping 260 matching lines @@
 
 void HOptimizedGraphBuilder::VisitRegExpLiteral(RegExpLiteral* expr) {
   DCHECK(!HasStackOverflow());
   DCHECK(current_block() != NULL);
   DCHECK(current_block()->HasPredecessor());
   Callable callable = CodeFactory::FastCloneRegExp(isolate());
   HValue* values[] = {
       context(), AddThisFunction(), Add<HConstant>(expr->literal_index()),
       Add<HConstant>(expr->pattern()), Add<HConstant>(expr->flags())};
   HConstant* stub_value = Add<HConstant>(callable.code());
-  HInstruction* instr =
-      New<HCallWithDescriptor>(stub_value, 0, callable.descriptor(),
-                               Vector<HValue*>(values, arraysize(values)));
+  HInstruction* instr = New<HCallWithDescriptor>(
+      stub_value, 0, callable.descriptor(),
+      Vector<HValue*>(values, arraysize(values)), NORMAL_CALL);
   return ast_context()->ReturnInstruction(instr, expr->id());
 }
 
 
 static bool CanInlinePropertyAccess(Handle<Map> map) {
   if (map->instance_type() == HEAP_NUMBER_TYPE) return true;
   if (map->instance_type() < FIRST_NONSTRING_TYPE) return true;
   return map->IsJSObjectMap() && !map->is_dictionary_map() &&
          !map->has_named_interceptor() &&
          // TODO(verwaest): Whitelist contexts to which we have access.
@@ skipping 764 matching lines @@
     int argument_count = 1;
     if (!info->IsLoad()) {
       argument_count = 2;
       Push(value);
     }
 
     if (info->accessor()->IsJSFunction() &&
         info->NeedsWrappingFor(Handle<JSFunction>::cast(info->accessor()))) {
       HValue* function = Add<HConstant>(info->accessor());
       PushArgumentsFromEnvironment(argument_count);
-      return NewCallFunction(function, argument_count, TailCallMode::kDisallow,
+      return NewCallFunction(function, argument_count,
                              ConvertReceiverMode::kNotNullOrUndefined,
                              TailCallMode::kDisallow);
     } else if (FLAG_inline_accessors && can_inline_accessor) {
       bool success = info->IsLoad()
           ? TryInlineGetter(info->accessor(), info->map(), ast_id, return_id)
           : TryInlineSetter(
               info->accessor(), info->map(), ast_id, return_id, value);
       if (success || HasStackOverflow()) return NULL;
     }
 
     PushArgumentsFromEnvironment(argument_count);
     if (!info->accessor()->IsJSFunction()) {
       Bailout(kInliningBailedOut);
       return nullptr;
     }
     return NewCallConstantFunction(Handle<JSFunction>::cast(info->accessor()),
-                                   argument_count, TailCallMode::kDisallow,
-                                   TailCallMode::kDisallow);
+                                   argument_count, TailCallMode::kDisallow);
   }
 
   DCHECK(info->IsDataConstant());
   if (info->IsLoad()) {
     return New<HConstant>(info->constant());
   } else {
     return New<HCheckValue>(value, Handle<JSFunction>::cast(info->constant()));
   }
 }
 
@@ skipping 1378 matching lines @@
 
 void HOptimizedGraphBuilder::AddCheckPrototypeMaps(Handle<JSObject> holder,
                                                    Handle<Map> receiver_map) {
   if (!holder.is_null()) {
     Handle<JSObject> prototype(JSObject::cast(receiver_map->prototype()));
     BuildCheckPrototypeMaps(prototype, holder);
   }
 }
 
 HInstruction* HOptimizedGraphBuilder::NewCallFunction(
-    HValue* function, int argument_count, TailCallMode syntactic_tail_call_mode,
-    ConvertReceiverMode convert_mode, TailCallMode tail_call_mode) {
+    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};
 
   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)),
-                                  syntactic_tail_call_mode);
+                                  Vector<HValue*>(op_vals, arraysize(op_vals)));
 }
 
 HInstruction* HOptimizedGraphBuilder::NewCallFunctionViaIC(
-    HValue* function, int argument_count, TailCallMode syntactic_tail_call_mode,
-    ConvertReceiverMode convert_mode, TailCallMode tail_call_mode,
-    FeedbackVectorSlot slot) {
+    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};
 
   Callable callable = CodeFactory::CallICInOptimizedCode(
       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)),
-                                  syntactic_tail_call_mode);
+                                  Vector<HValue*>(op_vals, arraysize(op_vals)));
 }
 
 HInstruction* HOptimizedGraphBuilder::NewCallConstantFunction(
     Handle<JSFunction> function, int argument_count,
-    TailCallMode syntactic_tail_call_mode, TailCallMode tail_call_mode) {
+    TailCallMode tail_call_mode) {
   HValue* target = Add<HConstant>(function);
-  return New<HInvokeFunction>(target, function, argument_count,
-                              syntactic_tail_call_mode, tail_call_mode);
+  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 130 matching lines @@
       // Trying to inline will signal that we should bailout from the
       // entire compilation by setting stack overflow on the visitor.
       if (HasStackOverflow()) return;
     } else {
       // Since HWrapReceiver currently cannot actually wrap numbers and strings,
       // use the regular call builtin for method calls to wrap the receiver.
       // TODO(verwaest): Support creation of value wrappers directly in
       // HWrapReceiver.
       HInstruction* call =
           needs_wrapping
-              ? NewCallFunction(
-                    function, argument_count, syntactic_tail_call_mode,
-                    ConvertReceiverMode::kNotNullOrUndefined, tail_call_mode)
-              : NewCallConstantFunction(target, argument_count,
-                                        syntactic_tail_call_mode,
-                                        tail_call_mode);
+              ? NewCallFunction(function, argument_count,
+                                ConvertReceiverMode::kNotNullOrUndefined,
+                                tail_call_mode)
+              : NewCallConstantFunction(target, argument_count, tail_call_mode);
       PushArgumentsFromEnvironment(argument_count);
       AddInstruction(call);
       Drop(1);  // Drop the function.
       if (!ast_context()->IsEffect()) Push(call);
     }
 
     if (current_block() != NULL) Goto(join);
     set_current_block(if_false);
   }
 
   // Finish up.  Unconditionally deoptimize if we've handled all the maps we
   // know about and do not want to handle ones we've never seen.  Otherwise
   // use a generic IC.
   if (ordered_functions == maps->length() && FLAG_deoptimize_uncommon_cases) {
     FinishExitWithHardDeoptimization(Deoptimizer::kUnknownMapInPolymorphicCall);
   } else {
     Property* prop = expr->expression()->AsProperty();
     HInstruction* function =
         BuildNamedGeneric(LOAD, prop, prop->PropertyFeedbackSlot(), receiver,
                           name, NULL, prop->IsUninitialized());
     AddInstruction(function);
     Push(function);
     AddSimulate(prop->LoadId(), REMOVABLE_SIMULATE);
 
     environment()->SetExpressionStackAt(1, function);
     environment()->SetExpressionStackAt(0, receiver);
     CHECK_ALIVE(VisitExpressions(expr->arguments()));
 
     HInstruction* call = NewCallFunction(
-        function, argument_count, syntactic_tail_call_mode,
-        ConvertReceiverMode::kNotNullOrUndefined, tail_call_mode);
+        function, argument_count, ConvertReceiverMode::kNotNullOrUndefined,
+        tail_call_mode);
 
     PushArgumentsFromEnvironment(argument_count);
 
     Drop(1);  // Function.
 
     if (join != NULL) {
       AddInstruction(call);
       if (!ast_context()->IsEffect()) Push(call);
       Goto(join);
     } else {
@@ skipping 865 matching lines @@
                              INITIALIZING_STORE);
 
             // Remember new length.
             Add<HStoreNamedField>(
                 receiver, HObjectAccess::ForArrayLength(kind),
                 new_length, STORE_TO_INITIALIZED_ENTRY);
           }
           if_inline.Else();
           {
             Add<HPushArguments>(receiver);
-            result = AddInstruction(NewCallConstantFunction(
-                function, 1, TailCallMode::kDisallow, TailCallMode::kDisallow));
+            result = AddInstruction(
+                NewCallConstantFunction(function, 1, TailCallMode::kDisallow));
             if (!ast_context()->IsEffect()) Push(result);
           }
           if_inline.End();
         }
         if_lengthiszero.End();
       }
       result = ast_context()->IsEffect() ? graph()->GetConstant0() : Top();
       Add<HSimulate>(expr->id(), REMOVABLE_SIMULATE);
       if (!ast_context()->IsEffect()) Drop(1);
       ast_context()->ReturnValue(result);
@@ skipping 243 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);
 
   PushArgumentsFromEnvironment(arguments_count);
-  HInvokeFunction* call =
-      New<HInvokeFunction>(function, known_function, arguments_count,
-                           syntactic_tail_call_mode, tail_call_mode);
+  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 376 matching lines @@
       }
       if (TryInlineApiMethodCall(expr, receiver, maps)) return;
 
       // Wrap the receiver if necessary.
       if (NeedsWrapping(maps->first(), known_function)) {
         // Since HWrapReceiver currently cannot actually wrap numbers and
         // strings, use the regular call builtin for method calls to wrap
         // the receiver.
         // TODO(verwaest): Support creation of value wrappers directly in
         // HWrapReceiver.
-        call = NewCallFunction(
-            function, argument_count, syntactic_tail_call_mode,
-            ConvertReceiverMode::kNotNullOrUndefined, tail_call_mode);
+        call = NewCallFunction(function, argument_count,
+                               ConvertReceiverMode::kNotNullOrUndefined,
+                               tail_call_mode);
       } else if (TryInlineCall(expr)) {
         return;
       } else {
-        call =
-            NewCallConstantFunction(known_function, argument_count,
-                                    syntactic_tail_call_mode, tail_call_mode);
+        call = NewCallConstantFunction(known_function, argument_count,
+                                       tail_call_mode);
       }
 
     } else {
       ArgumentsAllowedFlag arguments_flag = ARGUMENTS_NOT_ALLOWED;
       if (CanBeFunctionApplyArguments(expr) && expr->is_uninitialized()) {
         // We have to use EAGER deoptimization here because Deoptimizer::SOFT
         // gets ignored by the always-opt flag, which leads to incorrect code.
         Add<HDeoptimize>(
             Deoptimizer::kInsufficientTypeFeedbackForCallWithArguments,
             Deoptimizer::EAGER);
         arguments_flag = ARGUMENTS_FAKED;
       }
 
       // Push the function under the receiver.
       environment()->SetExpressionStackAt(0, function);
       Push(receiver);
 
       CHECK_ALIVE(VisitExpressions(expr->arguments(), arguments_flag));
-      call = NewCallFunction(function, argument_count, syntactic_tail_call_mode,
+      call = NewCallFunction(function, argument_count,
                              ConvertReceiverMode::kNotNullOrUndefined,
                              tail_call_mode);
     }
     PushArgumentsFromEnvironment(argument_count);
 
   } else {
     VariableProxy* proxy = expr->expression()->AsVariableProxy();
     if (proxy != NULL && proxy->var()->is_possibly_eval(isolate())) {
       return Bailout(kPossibleDirectCallToEval);
     }
@@ skipping 29 matching lines @@
           PrintF("\n");
         }
         return;
       }
       if (TryInlineApiFunctionCall(expr, receiver)) return;
       if (TryHandleArrayCall(expr, function)) return;
       if (TryInlineCall(expr)) return;
 
       PushArgumentsFromEnvironment(argument_count);
       call = NewCallConstantFunction(expr->target(), argument_count,
-                                     syntactic_tail_call_mode, tail_call_mode);
+                                     tail_call_mode);
     } else {
       PushArgumentsFromEnvironment(argument_count);
       if (expr->is_uninitialized() &&
           expr->IsUsingCallFeedbackICSlot(isolate())) {
         // We've never seen this call before, so let's have Crankshaft learn
         // through the type vector.
         call = NewCallFunctionViaIC(function, argument_count,
-                                    syntactic_tail_call_mode,
                                     ConvertReceiverMode::kNullOrUndefined,
                                     tail_call_mode, expr->CallFeedbackICSlot());
       } else {
-        call = NewCallFunction(
-            function, argument_count, syntactic_tail_call_mode,
-            ConvertReceiverMode::kNullOrUndefined, tail_call_mode);
+        call = NewCallFunction(function, argument_count,
+                               ConvertReceiverMode::kNullOrUndefined,
+                               tail_call_mode);
       }
     }
   }
 
   Drop(1);  // Drop the function.
   return ast_context()->ReturnInstruction(call, expr->id());
 }
 
 
 void HOptimizedGraphBuilder::BuildInlinedCallArray(
@@ skipping 612 matching lines @@
     // The callee and the receiver both have to be pushed onto the operand stack
     // before arguments are being evaluated.
     HValue* function = AddLoadJSBuiltin(expr->context_index());
     HValue* receiver = graph()->GetConstantUndefined();
     Push(function);
     Push(receiver);
 
     int argument_count = expr->arguments()->length() + 1;  // Count receiver.
     CHECK_ALIVE(VisitExpressions(expr->arguments()));
     PushArgumentsFromEnvironment(argument_count);
-    HInstruction* call = NewCallFunction(
-        function, argument_count, TailCallMode::kDisallow,
-        ConvertReceiverMode::kNullOrUndefined, TailCallMode::kDisallow);
+    HInstruction* call = NewCallFunction(function, argument_count,
+                                         ConvertReceiverMode::kNullOrUndefined,
+                                         TailCallMode::kDisallow);
     Drop(1);  // Function
     return ast_context()->ReturnInstruction(call, expr->id());
   }
 
   const Runtime::Function* function = expr->function();
   DCHECK(function != NULL);
   switch (function->function_id) {
 #define CALL_INTRINSIC_GENERATOR(Name) \
   case Runtime::kInline##Name:         \
     return Generate##Name(expr);
@@ skipping 3006 matching lines @@
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8