[ic] Refactoring definition of a smi-encoded load handlers.

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 5256 matching lines @@
 
   // |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 = DecodeWord<LoadHandlerTypeBits>(handler_word);
+    Node* handler_kind = DecodeWord<LoadHandler::KindBits>(handler_word);
     if (support_elements == kSupportElements) {
       Label property(this);
       GotoUnless(
-          WordEqual(handler_type, IntPtrConstant(kLoadICHandlerForElements)),
+          WordEqual(handler_kind, IntPtrConstant(LoadHandler::kForElements)),
           &property);
 
       Comment("element_load");
       Node* intptr_index = TryToIntptr(p->name, miss);
       Node* elements = LoadElements(holder);
-      Node* is_jsarray_condition = IsSetWord<KeyedLoadIsJsArray>(handler_word);
-      Node* elements_kind = DecodeWord<KeyedLoadElementsKind>(handler_word);
+      Node* is_jsarray_condition =
+          IsSetWord<LoadHandler::IsJsArrayBits>(handler_word);
+      Node* elements_kind =
+          DecodeWord<LoadHandler::ElementsKindBits>(handler_word);
       Label if_hole(this), unimplemented_elements_kind(this);
       Label* out_of_bounds = miss;
       EmitElementLoad(holder, elements, elements_kind, intptr_index,
                       is_jsarray_condition, &if_hole, &rebox_double,
                       &var_double_value, &unimplemented_elements_kind,
                       out_of_bounds, miss);
 
       Bind(&unimplemented_elements_kind);
       {
         // Smi handlers should only be installed for supported elements kinds.
         // Crash if we get here.
         DebugBreak();
         Goto(miss);
       }
 
       Bind(&if_hole);
       {
         Comment("convert hole");
-        GotoUnless(IsSetWord<KeyedLoadConvertHole>(handler_word), miss);
+        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))),
             miss);
         Return(UndefinedConstant());
       }
 
       Bind(&property);
       Comment("property_load");
     }
 
     Label constant(this), field(this);
-    Branch(WordEqual(handler_type, IntPtrConstant(kLoadICHandlerForFields)),
+    Branch(WordEqual(handler_kind, IntPtrConstant(LoadHandler::kForFields)),
            &field, &constant);
 
     Bind(&field);
     {
       Comment("field_load");
-      Node* offset = DecodeWord<FieldOffsetOffset>(handler_word);
+      Node* offset = DecodeWord<LoadHandler::FieldOffsetBits>(handler_word);
 
       Label inobject(this), out_of_object(this);
-      Branch(IsSetWord<FieldOffsetIsInobject>(handler_word), &inobject,
+      Branch(IsSetWord<LoadHandler::IsInobjectBits>(handler_word), &inobject,
              &out_of_object);
 
       Bind(&inobject);
       {
         Label is_double(this);
-        GotoIf(IsSetWord<FieldOffsetIsDouble>(handler_word), &is_double);
+        GotoIf(IsSetWord<LoadHandler::IsDoubleBits>(handler_word), &is_double);
         Return(LoadObjectField(holder, offset));
 
         Bind(&is_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);
       {
         Label is_double(this);
         Node* properties = LoadProperties(holder);
         Node* value = LoadObjectField(properties, offset);
-        GotoIf(IsSetWord<FieldOffsetIsDouble>(handler_word), &is_double);
+        GotoIf(IsSetWord<LoadHandler::IsDoubleBits>(handler_word), &is_double);
         Return(value);
 
         Bind(&is_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 = DecodeWord<ValueIndexInDescriptorArray>(handler_word);
+      Node* descriptor =
+          DecodeWord<LoadHandler::DescriptorValueIndexBits>(handler_word);
 #if defined(DEBUG)
       CSA_ASSERT(UintPtrLessThan(
           descriptor, LoadAndUntagFixedArrayBaseLength(descriptors)));
 #endif
       Return(
           LoadFixedArrayElement(descriptors, descriptor, 0, INTPTR_PARAMETERS));
     }
   }
 
   Bind(&try_proto_cell_handler);
@@ skipping 2924 matching lines @@
   Node* buffer_bit_field = LoadObjectField(
       buffer, JSArrayBuffer::kBitFieldOffset, MachineType::Uint32());
   Node* was_neutered_mask = Int32Constant(JSArrayBuffer::WasNeutered::kMask);
 
   return Word32NotEqual(Word32And(buffer_bit_field, was_neutered_mask),
                         Int32Constant(0));
 }
 
 }  // namespace internal
 }  // namespace v8