[crankshaft] Remove useless HCallJSFunction instruction.

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 6571 matching lines @@
           : 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 BuildCallConstantFunction(Handle<JSFunction>::cast(info->accessor()),
-                                     argument_count);
+    return NewCallConstantFunction(Handle<JSFunction>::cast(info->accessor()),
+                                   argument_count);
   }
 
   DCHECK(info->IsDataConstant());
   if (info->IsLoad()) {
     return New<HConstant>(info->constant());
   } else {
     return New<HCheckValue>(value, Handle<JSFunction>::cast(info->constant()));
   }
 }
 
@@ skipping 1377 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::NewPlainFunctionCall(HValue* function,
-                                                           int argument_count) {
-  return New<HCallJSFunction>(function, argument_count);
-}
-
-HInstruction* HOptimizedGraphBuilder::NewArgumentAdaptorCall(
-    HValue* function, int argument_count, HValue* expected_param_count) {
-  HValue* context = Add<HLoadNamedField>(
-      function, nullptr, HObjectAccess::ForFunctionContextPointer());
-  HValue* new_target = graph()->GetConstantUndefined();
-  HValue* arity = Add<HConstant>(argument_count - 1);
-
-  HValue* op_vals[] = {context, function, new_target, arity,
-                       expected_param_count};
-
-  Callable callable = CodeFactory::ArgumentAdaptor(isolate());
-  HConstant* stub = Add<HConstant>(callable.code());
-
-  return New<HCallWithDescriptor>(stub, argument_count, callable.descriptor(),
-                                  Vector<HValue*>(op_vals, arraysize(op_vals)));
-}
-
 HInstruction* HOptimizedGraphBuilder::NewCallFunction(
     HValue* function, int argument_count, ConvertReceiverMode convert_mode) {
   HValue* arity = Add<HConstant>(argument_count - 1);
 
   HValue* op_vals[] = {context(), function, arity};
 
   Callable callable = CodeFactory::Call(isolate(), convert_mode);
   HConstant* stub = Add<HConstant>(callable.code());
 
   return New<HCallWithDescriptor>(stub, argument_count, callable.descriptor(),
@@ skipping 11 matching lines @@
   HValue* op_vals[] = {context(), function, index_val, vector_val};
 
   Callable callable = CodeFactory::CallICInOptimizedCode(
       isolate(), arity, ConvertReceiverMode::kNullOrUndefined);
   HConstant* stub = Add<HConstant>(callable.code());
 
   return New<HCallWithDescriptor>(stub, argument_count, callable.descriptor(),
                                   Vector<HValue*>(op_vals, arraysize(op_vals)));
 }
 
-HInstruction* HOptimizedGraphBuilder::BuildCallConstantFunction(
-    Handle<JSFunction> jsfun, int argument_count) {
-  HValue* target = Add<HConstant>(jsfun);
-  // For constant functions, we try to avoid calling the
-  // argument adaptor and instead call the function directly
-  int formal_parameter_count =
-      jsfun->shared()->internal_formal_parameter_count();
-  bool dont_adapt_arguments =
-      (formal_parameter_count ==
-       SharedFunctionInfo::kDontAdaptArgumentsSentinel);
-  int arity = argument_count - 1;
-  bool can_invoke_directly =
-      dont_adapt_arguments || formal_parameter_count == arity;
-  if (can_invoke_directly) {
-    return NewPlainFunctionCall(target, argument_count);
-  } else {
-    HValue* param_count_value = Add<HConstant>(formal_parameter_count);
-    return NewArgumentAdaptorCall(target, argument_count, param_count_value);
-  }
-  UNREACHABLE();
-  return NULL;
+HInstruction* HOptimizedGraphBuilder::NewCallConstantFunction(
+    Handle<JSFunction> function, int argument_count) {
+  HValue* target = Add<HConstant>(function);
+  return New<HInvokeFunction>(target, function, argument_count);
 }
 
 
 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 128 matching lines @@
       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,
                                 ConvertReceiverMode::kNotNullOrUndefined)
-              : BuildCallConstantFunction(target, argument_count);
+              : NewCallConstantFunction(target, argument_count);
       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);
   }
 
@@ skipping 798 matching lines @@
       // in a map change.
       BuildCheckPrototypeMaps(
           handle(JSObject::cast(receiver_map->prototype()), isolate()),
           Handle<JSObject>::null());
 
       // Threshold for fast inlined Array.shift().
       HConstant* inline_threshold = Add<HConstant>(static_cast<int32_t>(16));
 
       Drop(args_count_no_receiver);
       HValue* receiver = Pop();
-      HValue* function = Pop();
+      Drop(1);  // Function.
       HValue* result;
 
       {
         NoObservableSideEffectsScope scope(this);
 
         HValue* length = Add<HLoadNamedField>(
             receiver, nullptr, HObjectAccess::ForArrayLength(kind));
 
         IfBuilder if_lengthiszero(this);
         HValue* lengthiszero = if_lengthiszero.If<HCompareNumericAndBranch>(
@@ skipping 55 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 = Add<HCallJSFunction>(function, 1);
+            result = AddInstruction(NewCallConstantFunction(function, 1));
             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 656 matching lines @@
         // 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,
                                ConvertReceiverMode::kNotNullOrUndefined);
       } else if (TryInlineCall(expr)) {
         return;
       } else {
-        call = BuildCallConstantFunction(known_function, argument_count);
+        call = NewCallConstantFunction(known_function, argument_count);
       }
 
     } 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);
@@ skipping 46 matching lines @@
           expr->target()->ShortPrint();
           PrintF("\n");
         }
         return;
       }
       if (TryInlineApiFunctionCall(expr, receiver)) return;
       if (TryHandleArrayCall(expr, function)) return;
       if (TryInlineCall(expr)) return;
 
       PushArgumentsFromEnvironment(argument_count);
-      call = BuildCallConstantFunction(expr->target(), argument_count);
+      call = NewCallConstantFunction(expr->target(), argument_count);
     } 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,
                                     ConvertReceiverMode::kNullOrUndefined,
                                     expr->CallFeedbackICSlot());
       } else {
@@ skipping 3630 matching lines @@
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8