Fastpath some spread-call desugaring.

src/code-stub-assembler.cc

 // Copyright 2016 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/code-stub-assembler.h"
 #include "src/code-factory.h"
 #include "src/frames-inl.h"
 #include "src/frames.h"
 #include "src/ic/handler-configuration.h"
 #include "src/ic/stub-cache.h"
 
@@ skipping 5552 matching lines @@
     }
 
     Bind(&if_hole);
     {
       Comment("convert hole");
       GotoUnless(IsSetWord<LoadHandler::ConvertHoleBits>(handler_word), miss);
       Node* protector_cell = LoadRoot(Heap::kArrayProtectorRootIndex);
       DCHECK(isolate()->heap()->array_protector()->IsPropertyCell());
       GotoUnless(
           WordEqual(LoadObjectField(protector_cell, PropertyCell::kValueOffset),
-                    SmiConstant(Smi::FromInt(Isolate::kArrayProtectorValid))),
+                    SmiConstant(Smi::FromInt(Isolate::kProtectorValid))),
           miss);
       Return(UndefinedConstant());
     }
 
     Bind(&property);
     Comment("property_load");
   }
 
   Label constant(this), field(this);
   Branch(WordEqual(handler_kind, IntPtrConstant(LoadHandler::kForFields)),
@@ skipping 3173 matching lines @@
 compiler::Node* CodeStubAssembler::InstanceOf(compiler::Node* object,
                                               compiler::Node* callable,
                                               compiler::Node* context) {
   Label return_runtime(this, Label::kDeferred), end(this);
   Variable result(this, MachineRepresentation::kTagged);
 
   // Check if no one installed @@hasInstance somewhere.
   GotoUnless(
       WordEqual(LoadObjectField(LoadRoot(Heap::kHasInstanceProtectorRootIndex),
                                 PropertyCell::kValueOffset),
-                SmiConstant(Smi::FromInt(Isolate::kArrayProtectorValid))),
+                SmiConstant(Smi::FromInt(Isolate::kProtectorValid))),
       &return_runtime);
 
   // Check if {callable} is a valid receiver.
   GotoIf(TaggedIsSmi(callable), &return_runtime);
   GotoUnless(IsCallableMap(LoadMap(callable)), &return_runtime);
 
   // Use the inline OrdinaryHasInstance directly.
   result.Bind(OrdinaryHasInstance(context, callable, object));
   Goto(&end);
 
@@ skipping 164 matching lines @@
           // Fast holey JSArrays can treat the hole as undefined if the
           // protector cell is valid, and the prototype chain is unchanged from
           // its initial state (because the protector cell is only tracked for
           // initial the Array and Object prototypes). Check these conditions
           // here, and take the slow path if any fail.
           Node* protector_cell = LoadRoot(Heap::kArrayProtectorRootIndex);
           DCHECK(isolate()->heap()->array_protector()->IsPropertyCell());
           GotoUnless(
               WordEqual(
                   LoadObjectField(protector_cell, PropertyCell::kValueOffset),
-                  SmiConstant(Smi::FromInt(Isolate::kArrayProtectorValid))),
+                  SmiConstant(Smi::FromInt(Isolate::kProtectorValid))),
               &if_isslow);
 
           Node* native_context = LoadNativeContext(context);
 
           Node* prototype = LoadMapPrototype(array_map);
           Node* array_prototype = LoadContextElement(
               native_context, Context::INITIAL_ARRAY_PROTOTYPE_INDEX);
           GotoUnless(WordEqual(prototype, array_prototype), &if_isslow);
 
           Node* map = LoadMap(prototype);
@@ skipping 176 matching lines @@
   STATIC_ASSERT(FAST_HOLEY_ELEMENTS == (FAST_ELEMENTS | 1));
   STATIC_ASSERT(FAST_HOLEY_DOUBLE_ELEMENTS == (FAST_DOUBLE_ELEMENTS | 1));
 
   // Check prototype chain if receiver does not have packed elements.
   Node* holey_elements = Word32And(elements_kind, Int32Constant(1));
   return Word32Equal(holey_elements, Int32Constant(1));
 }
 
 }  // namespace internal
 }  // namespace v8