[ic] Refactor LoadIC code.

Extract CSA::HandleLoadICSmiHandlerCase() from CSA::HandleLoadICHandlerCase() and
CSA::EmitLoadICProtoArrayCheck() from CSA::HandleLoadICProtoHandler().

This is a preliminary step for extracting LoadICProtoArrayCheck to a separate stub
which is necesary to fix the preformance regression caused by proto array
handlers support.

BUG=v8:5561, chromium:660795

Review-Url: https://codereview.chromium.org/2498013002
Cr-Commit-Position: refs/heads/master@{#40983}

src/code-stub-assembler.cc

@@ -5504,11 +5504,35 @@ void CodeStubAssembler::HandleLoadICHandlerCase(
   // for the encoding format.
   Bind(&if_smi_handler);
   {
+    HandleLoadICSmiHandlerCase(p, var_holder.value(), var_smi_handler.value(),
+                               miss, support_elements);
+  }
+
+  Bind(&try_proto_handler);
+  {
+    GotoIf(IsCodeMap(LoadMap(handler)), &call_handler);
+    HandleLoadICProtoHandler(p, handler, &var_holder, &var_smi_handler,
+                             &if_smi_handler, miss);
+  }
+
+  Bind(&call_handler);
+  {
+    typedef LoadWithVectorDescriptor Descriptor;
+    TailCallStub(Descriptor(isolate()), handler, p->context,
+                 Arg(Descriptor::kReceiver, p->receiver),
+                 Arg(Descriptor::kName, p->name),
+                 Arg(Descriptor::kSlot, p->slot),
+                 Arg(Descriptor::kVector, p->vector));
+  }
+}
+
+void CodeStubAssembler::HandleLoadICSmiHandlerCase(
+    const LoadICParameters* p, Node* holder, Node* smi_handler, Label* miss,
+    ElementSupport support_elements) {
   Variable var_double_value(this, MachineRepresentation::kFloat64);
   Label rebox_double(this, &var_double_value);
 
-    Node* holder = var_holder.value();
-    Node* handler_word = SmiUntag(var_smi_handler.value());
+  Node* handler_word = SmiUntag(smi_handler);
   Node* handler_kind = DecodeWord<LoadHandler::KindBits>(handler_word);
   if (support_elements == kSupportElements) {
     Label property(this);
@@ -5545,8 +5569,7 @@ void CodeStubAssembler::HandleLoadICHandlerCase(
       Node* protector_cell = LoadRoot(Heap::kArrayProtectorRootIndex);
       DCHECK(isolate()->heap()->array_protector()->IsPropertyCell());
       GotoUnless(
-            WordEqual(
-                LoadObjectField(protector_cell, PropertyCell::kValueOffset),
+          WordEqual(LoadObjectField(protector_cell, PropertyCell::kValueOffset),
                     SmiConstant(Smi::FromInt(Isolate::kArrayProtectorValid))),
           miss);
       Return(UndefinedConstant());
@@ -5609,11 +5632,9 @@ void CodeStubAssembler::HandleLoadICHandlerCase(
     Node* descriptors = LoadMapDescriptors(LoadMap(holder));
     Node* descriptor =
         DecodeWord<LoadHandler::DescriptorValueIndexBits>(handler_word);
-#if defined(DEBUG)
-      CSA_ASSERT(
-          this, UintPtrLessThan(descriptor,
+    CSA_ASSERT(this,
+               UintPtrLessThan(descriptor,
                                LoadAndUntagFixedArrayBaseLength(descriptors)));
-#endif
     Node* value =
         LoadFixedArrayElement(descriptors, descriptor, 0, INTPTR_PARAMETERS);
 
@@ -5626,24 +5647,6 @@ void CodeStubAssembler::HandleLoadICHandlerCase(
     Callable callable = CodeFactory::ApiGetter(isolate());
     TailCallStub(callable, p->context, p->receiver, holder, value);
   }
-  }
-
-  Bind(&try_proto_handler);
-  {
-    GotoIf(IsCodeMap(LoadMap(handler)), &call_handler);
-    HandleLoadICProtoHandler(p, handler, &var_holder, &var_smi_handler,
-                             &if_smi_handler, miss);
-  }
-
-  Bind(&call_handler);
-  {
-    typedef LoadWithVectorDescriptor Descriptor;
-    TailCallStub(Descriptor(isolate()), handler, p->context,
-                 Arg(Descriptor::kReceiver, p->receiver),
-                 Arg(Descriptor::kName, p->name),
-                 Arg(Descriptor::kSlot, p->slot),
-                 Arg(Descriptor::kVector, p->vector));
-  }
 }
 
 void CodeStubAssembler::HandleLoadICProtoHandler(
@@ -5712,14 +5715,25 @@ void CodeStubAssembler::HandleLoadICProtoHandler(
 
   Bind(&array_handler);
   {
-    Node* length = SmiUntag(maybe_holder_cell);
+    Node* handler_length = SmiUntag(maybe_holder_cell);
+    Node* holder = EmitLoadICProtoArrayCheck(p, handler, handler_length,
+                                             handler_flags, miss);
+    var_holder->Bind(holder);
+    var_smi_handler->Bind(smi_handler);
+    Goto(if_smi_handler);
+  }
+}
 
+Node* CodeStubAssembler::EmitLoadICProtoArrayCheck(const LoadICParameters* p,
+                                                   Node* handler,
+                                                   Node* handler_length,
+                                                   Node* handler_flags,
+                                                   Label* miss) {
   Variable start_index(this, MachineType::PointerRepresentation());
   start_index.Bind(IntPtrConstant(LoadHandler::kFirstPrototypeIndex));
 
   Label can_access(this);
-    GotoUnless(
-        IsSetWord<LoadHandler::DoAccessCheckOnReceiverBits>(handler_flags),
+  GotoUnless(IsSetWord<LoadHandler::DoAccessCheckOnReceiverBits>(handler_flags),
              &can_access);
   {
     // Skip this entry of a handler.
@@ -5745,11 +5759,11 @@ void CodeStubAssembler::HandleLoadICProtoHandler(
   }
   Bind(&can_access);
 
-    BuildFastLoop(MachineType::PointerRepresentation(), start_index.value(),
-                  length,
+  BuildFastLoop(
+      MachineType::PointerRepresentation(), start_index.value(), handler_length,
       [this, p, handler, miss](CodeStubAssembler*, Node* current) {
-                    Node* prototype_cell = LoadFixedArrayElement(
-                        handler, current, 0, INTPTR_PARAMETERS);
+        Node* prototype_cell =
+            LoadFixedArrayElement(handler, current, 0, INTPTR_PARAMETERS);
         CheckPrototype(prototype_cell, p->name, miss);
       },
       1, IndexAdvanceMode::kPost);
@@ -5768,11 +5782,7 @@ void CodeStubAssembler::HandleLoadICProtoHandler(
   // the receiver map check, the validity cell check and the prototype chain
   // check.
   CSA_ASSERT(this, WordNotEqual(holder, IntPtrConstant(0)));
-
-    var_holder->Bind(holder);
-    var_smi_handler->Bind(smi_handler);
-    Goto(if_smi_handler);
-  }
+  return holder;
 }
 
 void CodeStubAssembler::CheckPrototype(Node* prototype_cell, Node* name,

src/code-stub-assembler.h

@@ -1144,11 +1144,22 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
       const LoadICParameters* p, compiler::Node* handler, Label* miss,
       ElementSupport support_elements = kOnlyProperties);
 
+  void HandleLoadICSmiHandlerCase(const LoadICParameters* p,
+                                  compiler::Node* holder,
+                                  compiler::Node* smi_handler, Label* miss,
+                                  ElementSupport support_elements);
+
   void HandleLoadICProtoHandler(const LoadICParameters* p,
                                 compiler::Node* handler, Variable* var_holder,
                                 Variable* var_smi_handler,
                                 Label* if_smi_handler, Label* miss);
 
+  compiler::Node* EmitLoadICProtoArrayCheck(const LoadICParameters* p,
+                                            compiler::Node* handler,
+                                            compiler::Node* handler_length,
+                                            compiler::Node* handler_flags,
+                                            Label* miss);
+
   void CheckPrototype(compiler::Node* prototype_cell, compiler::Node* name,
                       Label* miss);