[ic] Smi-handlers are now able to represent loads of constants from descriptor array.

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 4818 matching lines @@
   var_holder.Bind(p->receiver);
   Variable var_smi_handler(this, MachineRepresentation::kTagged);
   var_smi_handler.Bind(handler);
 
   Variable* vars[] = {&var_holder, &var_smi_handler};
   Label if_smi_handler(this, 2, vars);
   Label try_proto_cell_handler(this), call_handler(this);
 
   Branch(TaggedIsSmi(handler), &if_smi_handler, &try_proto_cell_handler);
 
-  // |handler| is a Smi, encoding what to do. See handler-configuration.h
+  // |handler| is a Smi, encoding what to do. See SmiHandler methods
   // for the encoding format.
   Bind(&if_smi_handler);
   {
     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_type =
+        WordAnd(handler_word, IntPtrConstant(LoadHandlerTypeBits::kMask));
     if (support_elements == kSupportElements) {
       Label property(this);
-      Node* handler_type =
-          WordAnd(handler_word, IntPtrConstant(LoadHandlerTypeBit::kMask));
       GotoUnless(
           WordEqual(handler_type, IntPtrConstant(kLoadICHandlerForElements)),
           &property);
 
       Comment("element_load");
       Node* intptr_index = TryToIntptr(p->name, miss);
       Node* elements = LoadElements(holder);
       Node* is_jsarray =
           WordAnd(handler_word, IntPtrConstant(KeyedLoadIsJsArray::kMask));
       Node* is_jsarray_condition = WordNotEqual(is_jsarray, IntPtrConstant(0));
@@ skipping 26 matching lines @@
                 LoadObjectField(protector_cell, PropertyCell::kValueOffset),
                 SmiConstant(Smi::FromInt(Isolate::kArrayProtectorValid))),
             miss);
         Return(UndefinedConstant());
       }
 
       Bind(&property);
       Comment("property_load");
     }
 
-    // |handler_word| is a field index as obtained by
-    // FieldIndex.GetLoadByFieldOffset():
-    Label inobject_double(this), out_of_object(this),
-        out_of_object_double(this);
-    Node* inobject_bit =
-        WordAnd(handler_word, IntPtrConstant(FieldOffsetIsInobject::kMask));
-    Node* double_bit =
-        WordAnd(handler_word, IntPtrConstant(FieldOffsetIsDouble::kMask));
-    Node* offset =
-        WordSar(handler_word, IntPtrConstant(FieldOffsetOffset::kShift));
+    Label constant(this), field(this);
+    Branch(WordEqual(handler_type, IntPtrConstant(kLoadICHandlerForFields)),
+           &field, &constant);
 
-    GotoIf(WordEqual(inobject_bit, IntPtrConstant(0)), &out_of_object);
+    Bind(&field);
+    {
+      Comment("field_load");
+      Label inobject_double(this), out_of_object(this),
+          out_of_object_double(this);
+      Node* inobject_bit =
+          WordAnd(handler_word, IntPtrConstant(FieldOffsetIsInobject::kMask));
+      Node* double_bit =
+          WordAnd(handler_word, IntPtrConstant(FieldOffsetIsDouble::kMask));
+      Node* offset =
+          WordSar(handler_word, IntPtrConstant(FieldOffsetOffset::kShift));
 
-    GotoUnless(WordEqual(double_bit, IntPtrConstant(0)), &inobject_double);
-    Return(LoadObjectField(holder, offset));
+      GotoIf(WordEqual(inobject_bit, IntPtrConstant(0)), &out_of_object);
 
-    Bind(&inobject_double);
-    if (FLAG_unbox_double_fields) {
-      var_double_value.Bind(
-          LoadObjectField(holder, offset, MachineType::Float64()));
-    } else {
-      Node* mutable_heap_number = LoadObjectField(holder, offset);
-      var_double_value.Bind(LoadHeapNumberValue(mutable_heap_number));
+      GotoUnless(WordEqual(double_bit, IntPtrConstant(0)), &inobject_double);
+      Return(LoadObjectField(holder, offset));
+
+      Bind(&inobject_double);
+      if (FLAG_unbox_double_fields) {
+        var_double_value.Bind(
+            LoadObjectField(holder, offset, MachineType::Float64()));
+      } else {
+        Node* mutable_heap_number = LoadObjectField(holder, offset);
+        var_double_value.Bind(LoadHeapNumberValue(mutable_heap_number));
+      }
+      Goto(&rebox_double);
+
+      Bind(&out_of_object);
+      Node* properties = LoadProperties(holder);
+      Node* value = LoadObjectField(properties, offset);
+      GotoUnless(WordEqual(double_bit, IntPtrConstant(0)),
+                 &out_of_object_double);
+      Return(value);
+
+      Bind(&out_of_object_double);
+      var_double_value.Bind(LoadHeapNumberValue(value));
+      Goto(&rebox_double);
+
+      Bind(&rebox_double);
+      Return(AllocateHeapNumberWithValue(var_double_value.value()));
     }
-    Goto(&rebox_double);
 
-    Bind(&out_of_object);
-    Node* properties = LoadProperties(holder);
-    Node* value = LoadObjectField(properties, offset);
-    GotoUnless(WordEqual(double_bit, IntPtrConstant(0)), &out_of_object_double);
-    Return(value);
-
-    Bind(&out_of_object_double);
-    var_double_value.Bind(LoadHeapNumberValue(value));
-    Goto(&rebox_double);
-
-    Bind(&rebox_double);
-    Return(AllocateHeapNumberWithValue(var_double_value.value()));
+    Bind(&constant);
+    {
+      Comment("constant_load");
+      Node* descriptors = LoadMapDescriptors(LoadMap(holder));
+      Node* descriptor = WordSar(
+          handler_word, IntPtrConstant(ValueIndexInDescriptorArray::kShift));
+#if defined(DEBUG)
+      Assert(UintPtrLessThan(descriptor,
+                             LoadAndUntagFixedArrayBaseLength(descriptors)));
+#endif
+      Return(
+          LoadFixedArrayElement(descriptors, descriptor, 0, INTPTR_PARAMETERS));
+    }
   }
 
   Bind(&try_proto_cell_handler);
   {
     GotoIf(WordNotEqual(LoadMap(handler), LoadRoot(Heap::kTuple3MapRootIndex)),
            &call_handler);
     Node* validity_cell = LoadObjectField(handler, Tuple3::kValue1Offset);
     Node* cell_value = LoadObjectField(validity_cell, Cell::kValueOffset);
     GotoIf(WordNotEqual(cell_value,
                         SmiConstant(Smi::FromInt(Map::kPrototypeChainValid))),
@@ skipping 2498 matching lines @@
     result.Bind(CallRuntime(Runtime::kInstanceOf, context, object, callable));
     Goto(&end);
   }
 
   Bind(&end);
   return result.value();
 }
 
 }  // namespace internal
 }  // namespace v8