[cleanup] CSA: add helpers for accessing details/value via key_index

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"
 
 namespace v8 {
 namespace internal {
@@ skipping 4400 matching lines @@
   Node* entry_index = IntPtrMul(entry, IntPtrConstant(Dictionary::kEntrySize));
   return IntPtrAdd(entry_index, IntPtrConstant(Dictionary::kElementsStartIndex +
                                                field_index));
 }
 
 template Node* CodeStubAssembler::EntryToIndex<NameDictionary>(Node*, int);
 template Node* CodeStubAssembler::EntryToIndex<GlobalDictionary>(Node*, int);
 template Node* CodeStubAssembler::EntryToIndex<SeededNumberDictionary>(Node*,
                                                                        int);
 
+template <class ContainerType>
+Node* CodeStubAssembler::LoadDetailsForKeyIndex(Node* container,

[Igor Sheludko, 2017/02/09 09:14:09]

WDYT about s/For/By/ here and below?

I'd just inline these one-liners into the header to avoid explicit template
instantiations.

[Jakob Kummerow, 2017/02/09 22:21:28]

Done.
Done.

+                                                Node* key_index) {
+  const int kKeyToDetailsOffset =
+      (ContainerType::kEntryDetailsIndex - ContainerType::kEntryKeyIndex) *
+      kPointerSize;
+  return LoadAndUntagToWord32FixedArrayElement(container, key_index,
+                                               kKeyToDetailsOffset);
+}
+
+template Node* CodeStubAssembler::LoadDetailsForKeyIndex<DescriptorArray>(
+    Node*, Node*);
+template Node* CodeStubAssembler::LoadDetailsForKeyIndex<NameDictionary>(Node*,
+                                                                         Node*);
+template Node*
+CodeStubAssembler::LoadDetailsForKeyIndex<SeededNumberDictionary>(Node*, Node*);
+
+template <class ContainerType>
+Node* CodeStubAssembler::LoadValueForKeyIndex(Node* container,
+                                              Node* key_index) {
+  const int kKeyToValueOffset =
+      (ContainerType::kEntryValueIndex - ContainerType::kEntryKeyIndex) *
+      kPointerSize;
+  return LoadFixedArrayElement(container, key_index, kKeyToValueOffset);
+}
+
+template Node* CodeStubAssembler::LoadValueForKeyIndex<GlobalDictionary>(Node*,
+                                                                         Node*);
+template Node* CodeStubAssembler::LoadValueForKeyIndex<NameDictionary>(Node*,
+                                                                       Node*);
+template Node* CodeStubAssembler::LoadValueForKeyIndex<SeededNumberDictionary>(
+    Node*, Node*);
+
+template <class ContainerType>
+void CodeStubAssembler::StoreDetailsForKeyIndex(Node* container,
+                                                Node* key_index,
+                                                Node* details) {
+  const int kKeyToDetailsOffset =
+      (ContainerType::kEntryDetailsIndex - ContainerType::kEntryKeyIndex) *
+      kPointerSize;
+  StoreFixedArrayElement(container, key_index, details, SKIP_WRITE_BARRIER,
+                         kKeyToDetailsOffset);
+}
+
+template <class ContainerType>
+void CodeStubAssembler::StoreValueForKeyIndex(Node* container, Node* key_index,
+                                              Node* value) {
+  const int kKeyToValueOffset =
+      (ContainerType::kEntryValueIndex - ContainerType::kEntryKeyIndex) *
+      kPointerSize;
+  StoreFixedArrayElement(container, key_index, value, UPDATE_WRITE_BARRIER,
+                         kKeyToValueOffset);
+}
+
+template void CodeStubAssembler::StoreValueForKeyIndex<NameDictionary>(Node*,
+                                                                       Node*,
+                                                                       Node*);
+
 Node* CodeStubAssembler::HashTableComputeCapacity(Node* at_least_space_for) {
   Node* capacity = IntPtrRoundUpToPowerOfTwo32(
       WordShl(at_least_space_for, IntPtrConstant(1)));
   return IntPtrMax(capacity, IntPtrConstant(HashTableBase::kMinCapacity));
 }
 
 Node* CodeStubAssembler::IntPtrMax(Node* left, Node* right) {
   return SelectConstant(IntPtrGreaterThanOrEqual(left, right), left, right,
                         MachineType::PointerRepresentation());
 }
@@ skipping 220 matching lines @@
   UNREACHABLE();  // Use specializations instead.
 }
 
 template <>
 void CodeStubAssembler::InsertEntry<NameDictionary>(Node* dictionary,
                                                     Node* name, Node* value,
                                                     Node* index,
                                                     Node* enum_index) {
   // Store name and value.
   StoreFixedArrayElement(dictionary, index, name);
-  const int kNameToValueOffset =
-      (NameDictionary::kEntryValueIndex - NameDictionary::kEntryKeyIndex) *
-      kPointerSize;
-  StoreFixedArrayElement(dictionary, index, value, UPDATE_WRITE_BARRIER,
-                         kNameToValueOffset);
+  StoreValueForKeyIndex<NameDictionary>(dictionary, index, value);
 
   // Prepare details of the new property.
   const int kInitialIndex = 0;
   PropertyDetails d(kData, NONE, kInitialIndex, PropertyCellType::kNoCell);
   enum_index =
       SmiShl(enum_index, PropertyDetails::DictionaryStorageField::kShift);
   STATIC_ASSERT(kInitialIndex == 0);
   Variable var_details(this, MachineRepresentation::kTaggedSigned,
                        SmiOr(SmiConstant(d.AsSmi()), enum_index));
 
   // Private names must be marked non-enumerable.
   Label not_private(this, &var_details);
   GotoUnless(IsSymbolMap(LoadMap(name)), &not_private);
   Node* flags = SmiToWord32(LoadObjectField(name, Symbol::kFlagsOffset));
   const int kPrivateMask = 1 << Symbol::kPrivateBit;
   GotoUnless(IsSetWord32(flags, kPrivateMask), &not_private);
   Node* dont_enum =
       SmiShl(SmiConstant(DONT_ENUM), PropertyDetails::AttributesField::kShift);
   var_details.Bind(SmiOr(var_details.value(), dont_enum));
   Goto(&not_private);
   Bind(&not_private);
 
   // Finally, store the details.
-  const int kNameToDetailsOffset =
-      (NameDictionary::kEntryDetailsIndex - NameDictionary::kEntryKeyIndex) *
-      kPointerSize;
-  StoreFixedArrayElement(dictionary, index, var_details.value(),
-                         SKIP_WRITE_BARRIER, kNameToDetailsOffset);
+  StoreDetailsForKeyIndex<NameDictionary>(dictionary, index,
+                                          var_details.value());
 }
 
 template <>
 void CodeStubAssembler::InsertEntry<GlobalDictionary>(Node* dictionary,
                                                       Node* key, Node* value,
                                                       Node* index,
                                                       Node* enum_index) {
   UNIMPLEMENTED();
 }
 
@@ skipping 38 matching lines @@
 
 template void CodeStubAssembler::Add<NameDictionary>(Node*, Node*, Node*,
                                                      Label*);
 
 void CodeStubAssembler::DescriptorLookupLinear(Node* unique_name,
                                                Node* descriptors, Node* nof,
                                                Label* if_found,
                                                Variable* var_name_index,
                                                Label* if_not_found) {
   Node* first_inclusive = IntPtrConstant(DescriptorArray::ToKeyIndex(0));
-  Node* factor = IntPtrConstant(DescriptorArray::kDescriptorSize);
+  Node* factor = IntPtrConstant(DescriptorArray::kEntrySize);
   Node* last_exclusive = IntPtrAdd(first_inclusive, IntPtrMul(nof, factor));
 
   BuildFastLoop(last_exclusive, first_inclusive,
                 [this, descriptors, unique_name, if_found,
                  var_name_index](Node* name_index) {
                   Node* candidate_name =
                       LoadFixedArrayElement(descriptors, name_index);
                   var_name_index->Bind(name_index);
                   GotoIf(WordEqual(candidate_name, unique_name), if_found);
                 },
-                -DescriptorArray::kDescriptorSize, INTPTR_PARAMETERS,
+                -DescriptorArray::kEntrySize, INTPTR_PARAMETERS,
                 IndexAdvanceMode::kPre);
   Goto(if_not_found);
 }
 
 void CodeStubAssembler::TryLookupProperty(
     Node* object, Node* map, Node* instance_type, Node* unique_name,
     Label* if_found_fast, Label* if_found_dict, Label* if_found_global,
     Variable* var_meta_storage, Variable* var_name_index, Label* if_not_found,
     Label* if_bailout) {
   DCHECK_EQ(MachineRepresentation::kTagged, var_meta_storage->rep());
@@ skipping 87 matching lines @@
 
 void CodeStubAssembler::LoadPropertyFromFastObject(Node* object, Node* map,
                                                    Node* descriptors,
                                                    Node* name_index,
                                                    Variable* var_details,
                                                    Variable* var_value) {
   DCHECK_EQ(MachineRepresentation::kWord32, var_details->rep());
   DCHECK_EQ(MachineRepresentation::kTagged, var_value->rep());
   Comment("[ LoadPropertyFromFastObject");
 
-  const int name_to_details_offset =
-      (DescriptorArray::kDescriptorDetails - DescriptorArray::kDescriptorKey) *
-      kPointerSize;
-  const int name_to_value_offset =
-      (DescriptorArray::kDescriptorValue - DescriptorArray::kDescriptorKey) *
-      kPointerSize;
-
-  Node* details = LoadAndUntagToWord32FixedArrayElement(descriptors, name_index,
-                                                        name_to_details_offset);
+  Node* details =
+      LoadDetailsForKeyIndex<DescriptorArray>(descriptors, name_index);
   var_details->Bind(details);
 
   Node* location = DecodeWord32<PropertyDetails::LocationField>(details);
 
   Label if_in_field(this), if_in_descriptor(this), done(this);
   Branch(Word32Equal(location, Int32Constant(kField)), &if_in_field,
          &if_in_descriptor);
   Bind(&if_in_field);
   {
     Node* field_index =
@@ skipping 62 matching lines @@
     Bind(&rebox_double);
     {
       Comment("rebox_double");
       Node* heap_number = AllocateHeapNumberWithValue(var_double_value.value());
       var_value->Bind(heap_number);
       Goto(&done);
     }
   }
   Bind(&if_in_descriptor);
   {
-    Node* value =
-        LoadFixedArrayElement(descriptors, name_index, name_to_value_offset);
-    var_value->Bind(value);
+    var_value->Bind(
+        LoadValueForKeyIndex<DescriptorArray>(descriptors, name_index));
     Goto(&done);
   }
   Bind(&done);
 
   Comment("] LoadPropertyFromFastObject");
 }
 
 void CodeStubAssembler::LoadPropertyFromNameDictionary(Node* dictionary,
                                                        Node* name_index,
                                                        Variable* var_details,
                                                        Variable* var_value) {
   Comment("LoadPropertyFromNameDictionary");
   CSA_ASSERT(this, IsDictionary(dictionary));
-  const int name_to_details_offset =
-      (NameDictionary::kEntryDetailsIndex - NameDictionary::kEntryKeyIndex) *
-      kPointerSize;
-  const int name_to_value_offset =
-      (NameDictionary::kEntryValueIndex - NameDictionary::kEntryKeyIndex) *
-      kPointerSize;
 
-  Node* details = LoadAndUntagToWord32FixedArrayElement(dictionary, name_index,
-                                                        name_to_details_offset);
-
-  var_details->Bind(details);
-  var_value->Bind(
-      LoadFixedArrayElement(dictionary, name_index, name_to_value_offset));
+  var_details->Bind(
+      LoadDetailsForKeyIndex<NameDictionary>(dictionary, name_index));
+  var_value->Bind(LoadValueForKeyIndex<NameDictionary>(dictionary, name_index));
 
   Comment("] LoadPropertyFromNameDictionary");
 }
 
 void CodeStubAssembler::LoadPropertyFromGlobalDictionary(Node* dictionary,
                                                          Node* name_index,
                                                          Variable* var_details,
                                                          Variable* var_value,
                                                          Label* if_deleted) {
   Comment("[ LoadPropertyFromGlobalDictionary");
   CSA_ASSERT(this, IsDictionary(dictionary));
 
-  const int name_to_value_offset =
-      (GlobalDictionary::kEntryValueIndex - GlobalDictionary::kEntryKeyIndex) *
-      kPointerSize;
-
   Node* property_cell =
-      LoadFixedArrayElement(dictionary, name_index, name_to_value_offset);
+      LoadValueForKeyIndex<GlobalDictionary>(dictionary, name_index);
 
   Node* value = LoadObjectField(property_cell, PropertyCell::kValueOffset);
   GotoIf(WordEqual(value, TheHoleConstant()), if_deleted);
 
   var_value->Bind(value);
 
   Node* details = LoadAndUntagToWord32ObjectField(property_cell,
                                                   PropertyCell::kDetailsOffset);
   var_details->Bind(details);
 
@@ skipping 3355 matching lines @@
         formatted.c_str(), TENURED);
     CallRuntime(Runtime::kGlobalPrint, NoContextConstant(),
                 HeapConstant(string));
   }
   CallRuntime(Runtime::kDebugPrint, NoContextConstant(), tagged_value);
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8